package com.se.common;
	import java.text.DecimalFormat;
	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.Iterator;
	import java.util.List;

	/**
	 * 최상위 문자열 처리관련 유틸리티 클래스이다.
	 *
	 * @author jindoo
	 */
	public class StringUtils {

	    /**
	     * 빈<code>String</code>형 배열.
	     */
	    public static final String[] EMPTY_STRING_ARRAY = new String[0];

	    /**
	     * 빈 문자열<code>""</code>.
	     */
	    public static final String EMPTY = "";

	    /**
	     * The maximum size to which the padding constant(s) can expand.
	     */
	    private static final int PAD_LIMIT = 8192;

	    /**
	     * An array of <code>String</code>s used for padding.<br>
	     * Used for efficient space padding. The length of each String expands as
	     * needed.
	     */
	    private static final String[] PADDING = new String[Character.MAX_VALUE];

	    static {
	        // space padding is most common, start with 64 chars
	        PADDING[32] = "                                                                ";
	    }

	    // Empty checks
	    // -----------------------------------------------------------------------
	    /**
	     * 주어진 문자열이 빈문자열("")인지 null인지를 검사한다.<br>
	     * <ul>
	     * <li>StringUtils.isEmpty(null) = true
	     * <li>StringUtils.isEmpty(&quot;&quot;) = true
	     * <li>StringUtils.isEmpty(&quot; &quot;) = false
	     * <li>StringUtils.isEmpty(&quot;bob&quot;) = false
	     * <li>StringUtils.isEmpty(&quot; bob &quot;) = false
	     * </ul>
	     * <p>
	     * NOTE: 가능하면 동일한 기능을 하는 isBlank()메소드를 사용하기를 권장한다.<br>
	     * </p>
	     *
	     * @param str
	     *            체크하려는 문자열
	     * @return
	     */
	    public static boolean isEmpty(String str) {
	        return str == null || str.length() == 0;
	    }

	    /**
	     * 주어진 객체의 배열이 빈문자열("")인지 null인지를 검사한다.<br>
	     *
	     * @param array
	     *            체크하려는 배열
	     * @return
	     */
	    public static boolean isEmpty(Object[] array) {
	        if (array == null || array.length == 0) {
	            return true;
	        }
	        return false;
	    }
	    public static boolean addArrString(StringBuffer src, HashMap hm) {
			if (src.toString().length() > 0) {
				String lstChr = src.toString().substring(src.toString().length() - 1);
				if (lstChr.equals("}")) { src.append(",\n"); }
			}

			Iterator i = hm.keySet().iterator();

			StringBuffer sb = new StringBuffer("");
			while (i.hasNext()) {
				Object key = i.next();
				Object o = hm.get(key);

				String value = "";
				if (o != null) {
					value = (String)o;
				} else {
					value = "";
				}

				sb.append(sb.length() == 0 ? "" : ",").append(key).append(":\"").append(value).append("\"");
			}
			src.append("{").append(sb.toString()).append("}");
			return true;
		}
	    /**
	     * 주어진 Long Type의 배열이 빈문자열("")인지 null인지를 검사한다.<br>
	     *
	     * @param array
	     *            체크하려는 배열
	     * @return
	     */
	    public static boolean isEmpty(long[] array) {
	        if (array == null || array.length == 0) {
	            return true;
	        }
	        return false;
	    }

	    /**
	     * 주어진 Int Type의 배열이 빈문자열("")인지 null인지를 검사한다.<br>
	     *
	     * @param array
	     *            체크하려는 배열
	     * @return
	     */
	    public static boolean isEmpty(int[] array) {
	        if (array == null || array.length == 0) {
	            return true;
	        }
	        return false;
	    }

	    /**
	     * 주어진 Short Type의 배열이 빈문자열("")인지 null인지를 검사한다.<br>
	     *
	     * @param array
	     *            체크하려는 배열
	     * @return
	     */
	    public static boolean isEmpty(short[] array) {
	        if (array == null || array.length == 0) {
	            return true;
	        }
	        return false;
	    }

	    /**
	     * 주어진 Char Type의 배열이 빈문자열("")인지 null인지를 검사한다.<br>
	     *
	     * @param array
	     *            체크하려는 배열
	     * @return
	     */
	    public static boolean isEmpty(char[] array) {
	        if (array == null || array.length == 0) {
	            return true;
	        }
	        return false;
	    }

	    /**
	     * 주어진 Byte Type의 배열이 빈문자열("")인지 null인지를 검사한다.<br>
	     *
	     * @param array
	     *            체크하려는 배열
	     * @return
	     */
	    public static boolean isEmpty(byte[] array) {
	        if (array == null || array.length == 0) {
	            return true;
	        }
	        return false;
	    }

	    /**
	     * 주어진 Double Type의 배열이 빈문자열("")인지 null인지를 검사한다.<br>
	     *
	     * @param array
	     *            체크하려는 배열
	     * @return
	     */
	    public static boolean isEmpty(double[] array) {
	        if (array == null || array.length == 0) {
	            return true;
	        }
	        return false;
	    }

	    /**
	     * 주어진 Float Type의 배열이 빈문자열("")인지 null인지를 검사한다.<br>
	     *
	     * @param array
	     *            체크하려는 배열
	     * @return
	     */
	    public static boolean isEmpty(float[] array) {
	        if (array == null || array.length == 0) {
	            return true;
	        }
	        return false;
	    }

	    /**
	     * 주어진 Boolean Type의 배열이 빈문자열("")인지 null인지를 검사한다.<br>
	     *
	     * @param array
	     *            체크하려는 배열
	     * @return
	     */
	    public static boolean isEmpty(boolean[] array) {
	        if (array == null || array.length == 0) {
	            return true;
	        }
	        return false;
	    }

	    /**
	     * 주어진 문자열이 빈문자열("") 또는null값이 아닌지를 검사한다.<br>
	     * <ul>
	     * <li>StringUtils.isNotEmpty(null) = false
	     * <li>StringUtils.isNotEmpty(&quot;&quot;) = false
	     * <li>StringUtils.isNotEmpty(&quot; &quot;) = true
	     * <li>StringUtils.isNotEmpty(&quot;bob&quot;) = true
	     * <li>StringUtils.isNotEmpty(&quot; bob &quot;) = true
	     * </ul>
	     *
	     * @param str
	     *            체크하려는 문자열
	     * @return
	     */
	    public static boolean isNotEmpty(String str) {
	        return str != null && str.length() > 0;
	    }

	    /**
	     * 체크하려는 문자열이 공백문자("")이거나 아무문자도 없는 Whitespace 또는 null인지를 검사한다.
	     * <ul>
	     * <li>StringUtils.isBlank(null) = true
	     * <li>StringUtils.isBlank(&quot;&quot;) = true
	     * <li>StringUtils.isBlank(&quot; &quot;) = true
	     * <li>StringUtils.isBlank(&quot;bob&quot;) = false
	     * <li>StringUtils.isBlank(&quot; bob &quot;) = false
	     * </ul>
	     *
	     * @param str
	     *            검사하려는 문자열
	     * @return
	     */
	    public static boolean isBlank(String str) {
	        int strLen;
	        if (str == null || (strLen = str.length()) == 0) {
	            return true;
	        }
	        for (int i = 0; i < strLen; i++) {
	            if ((Character.isWhitespace(str.charAt(i)) == false)) {
	                return false;
	            }
	        }
	        return true;
	    }

	    /**
	     * 체크하려는 문자열이 공백문자("")이거나 아무문자도 없는 Whitespace 또는 null이 아닌지를 검사한다.<br>
	     * <ul>
	     * <li>StringUtils.isNotBlank(null) = false
	     * <li>StringUtils.isNotBlank(&quot;&quot;) = false
	     * <li>StringUtils.isNotBlank(&quot; &quot;) = false
	     * <li>StringUtils.isNotBlank(&quot;bob&quot;) = true
	     * <li>StringUtils.isNotBlank(&quot; bob &quot;) = true
	     * </ul>
	     *
	     * @param str
	     *            검사하려는 문자열
	     * @return
	     */
	    public static boolean isNotBlank(String str) {
	        int strLen;
	        if (str == null || (strLen = str.length()) == 0) {
	            return false;
	        }
	        for (int i = 0; i < strLen; i++) {
	            if ((Character.isWhitespace(str.charAt(i)) == false)) {
	                return true;
	            }
	        }
	        return false;
	    }

	    // Trim
	    // -----------------------------------------------------------------------
	    /**
	     * 문자열을 Trim한다. 문자열이 null인경우 null값을 반환한다. (특정문자를 Trim하려한다면
	     * {@link #strip(String, String)} 메소드를 이용하라.)
	     * <ul>
	     * <li>StringUtils.trim(null) = null
	     * <li>StringUtils.trim("") = ""
	     * <li>StringUtils.trim(" ") = ""
	     * <li>StringUtils.trim("abc") = "abc"
	     * <li>StringUtils.trim(" abc ") = "abc"
	     * </ul>
	     *
	     * @param str
	     *            Trim될 문자열
	     * @return
	     */
	    public static String trim(String str) {
	        return str == null ? null : str.trim();
	    }

	    /**
	     * Null이나 공백문자를 Trim할경우 Null값을 반환한다.
	     * <ul>
	     * <li>StringUtils.trimToNull(null) = null
	     * <li>StringUtils.trimToNull("") = null
	     * <li>StringUtils.trimToNull(" ") = null
	     * <li>StringUtils.trimToNull("abc") = "abc"
	     * <li>StringUtils.trimToNull(" abc ") = "abc"
	     * </ul>
	     *
	     * @param str
	     *            Trim될 문자열
	     * @return
	     */
	    public static String trimToNull(String str) {
	        String ts = trim(str);
	        return isEmpty(ts) ? null : ts;
	    }

	    /**
	     * 문자열을 Trim한다. 문자열이 <code>null</code>이거나 빈문자열이 더라도 <code>null</code>을
	     * 반환하지않고 빈 문자열을 반환한다.
	     * </p>
	     * <ul>
	     * <li>StringUtils.trimToEmpty(null) = ""
	     * <li>StringUtils.trimToEmpty("") = ""
	     * <li>StringUtils.trimToEmpty(" ") = ""
	     * <li>StringUtils.trimToEmpty("abc") = "abc"
	     * <li>StringUtils.trimToEmpty(" abc ") = "abc"
	     * </ul>
	     *
	     * @param str
	     *            Trim될 문자열
	     * @return
	     */
	    public static String trimToEmpty(String str) {
	        return str == null ? EMPTY : str.trim();
	    }

	    // Stripping
	    // -----------------------------------------------------------------------
	    /**
	     * 문자열의 양쪽에 공백문자가 존재한다면 공백문자를 삭제한 결과를 반환한다. <br>
	     * 문자열이 <code>null</code>인경우 <code>null</code>을 반환한다.
	     * <ul>
	     * <li>StringUtils.strip(null) = null
	     * <li>StringUtils.strip("") = ""
	     * <li>StringUtils.strip(" ") = ""
	     * <li>StringUtils.strip("abc") = "abc"
	     * <li>StringUtils.strip(" abc") = "abc"
	     * <li>StringUtils.strip("abc ") = "abc"
	     * <li>StringUtils.strip(" abc ") = "abc"
	     * <li>StringUtils.strip(" ab c ") = "ab c"
	     * </ul>
	     *
	     * @param str
	     *            양쪽에 공백문자가 제거될 문자열
	     * @return
	     */
	    public static String strip(String str) {
	        return strip(str, null);
	    }

	    /**
	     * 문자열의 양쪽의 공백문자를 제거한다. 주어진 문자열이 <code>null</code>이거나 빈 공백문자(또는 공맥문자로 채워진
	     * 문자열)일경우 Null값을 반환한다.
	     * <ul>
	     * <li>StringUtils.strip(null) = null
	     * <li>StringUtils.strip("") = null
	     * <li>StringUtils.strip(" ") = null
	     * <li>StringUtils.strip("abc") = "abc"
	     * <li>StringUtils.strip(" abc") = "abc"
	     * <li>StringUtils.strip("abc ") = "abc"
	     * <li>StringUtils.strip(" abc ") = "abc"
	     * <li>StringUtils.strip(" ab c ") = "ab c"
	     * </ul>
	     *
	     * @param str
	     *            양쪽에 공백문자가 제거될 문자열
	     * @return
	     */
	    public static String stripToNull(String str) {
	        if (str == null) {
	            return null;
	        }
	        str = strip(str, null);
	        return str.length() == 0 ? null : str;
	    }

	    /**
	     * 문자열의 양쪽의 공백문자를 제거한다. <br>
	     * 주어진 문자열이 <code>null</code>이거나 빈 공백문자(또는 공맥문자로 채워진 문자열)일경우 라도 Null값을
	     * 반환하지 않고 빈공백 문자를 반환한다.
	     * <ul>
	     * <li>StringUtils.strip(null) = ""
	     * <li>StringUtils.strip("") = ""
	     * <li>StringUtils.strip(" ") = ""
	     * <li>StringUtils.strip("abc") = "abc"
	     * <li>StringUtils.strip(" abc") = "abc"
	     * <li>StringUtils.strip("abc ") = "abc"
	     * <li>StringUtils.strip(" abc ") = "abc"
	     * <li>StringUtils.strip(" ab c ") = "ab c"
	     * </ul>
	     *
	     * @param str
	     *            양쪽에 공백문자가 제거될 문자열
	     * @return
	     */
	    public static String stripToEmpty(String str) {
	        return str == null ? EMPTY : strip(str, null);
	    }

	    /**
	     * <code>stripChars</code>에의해 지정된 문자 집합이 <code>str</code>의 양쪽에 있다면
	     * 해당되는 문자를 삭제한후 문자열을 반환한다.<br>
	     * 만일 <code>stripChars</code>가 <code>null</code>인경우 stripChars는 빈
	     * 공백문자로 취급되어 문자열의 양쪽에 빈 문자열을 삭제한다.
	     * <ul>
	     * <li>StringUtils.strip(null, *) = null
	     * <li>StringUtils.strip("", *) = ""
	     * <li>StringUtils.strip("abc", null) = "abc"
	     * <li>StringUtils.strip(" abc", null) = "abc"
	     * <li>StringUtils.strip("abc ", null) = "abc"
	     * <li>StringUtils.strip(" abc ", null) = "abc"
	     * <li>StringUtils.strip(" abcyx", "xyz") = " abc"
	     * </ul>
	     *
	     * @param str
	     *            문자열 양쪽에 지정된 문자집합이 있을경우 삭제될 문자열
	     * @param stripChars
	     *            삭제할 문자집합, NUll은 공백문자로 인식하여 처리한다.
	     * @return
	     */
	    public static String strip(String str, String stripChars) {
	        if (isEmpty(str)) {
	            return str;
	        }
	        str = stripStart(str, stripChars);
	        return stripEnd(str, stripChars);
	    }

	    /**
	     * <code>stripChars</code>에의해 지정된 문자 집합이 <code>str</code>의 앞쪽에 있다면
	     * 해당되는 문자를 삭제한후 문자열을 반환한다.<br>
	     * 만일 <code>stripChars</code>가 <code>null</code>인경우 stripChars는 빈
	     * 공백문자로 취급되어 문자열의 앞쪽에 빈 문자열을 삭제한다.
	     * <ul>
	     * <li>StringUtils.stripStart(null, *) = null
	     * <li>StringUtils.stripStart("", *) = ""
	     * <li>StringUtils.stripStart("abc", "") = "abc"
	     * <li>StringUtils.stripStart("abc", null) = "abc"
	     * <li>StringUtils.stripStart(" abc", null) = "abc"
	     * <li>StringUtils.stripStart("abc ", null) = "abc "
	     * <li>StringUtils.stripStart(" abc ", null) = "abc "
	     * <li>StringUtils.stripStart("yxabc ", "xyz") = "abc "
	     * </ul>
	     *
	     * @param str
	     *            문자열 앞쪽에 지정된 문자집합이 있을경우 삭제될 문자열
	     * @param stripChars
	     *            삭제할 문자집합, NUll은 공백문자로 인식하여 처리한다.
	     * @return
	     */
	    public static String stripStart(String str, String stripChars) {
	        int strLen;
	        if (str == null || (strLen = str.length()) == 0) {
	            return str;
	        }
	        int start = 0;
	        if (stripChars == null) {
	            while ((start != strLen)
	                    && Character.isWhitespace(str.charAt(start))) {
	                start++;
	            }
	        } else if (stripChars.length() == 0) {
	            return str;
	        } else {
	            while ((start != strLen)
	                    && (stripChars.indexOf(str.charAt(start)) != -1)) {
	                start++;
	            }
	        }
	        return str.substring(start);
	    }

	    /**
	     * <code>stripChars</code>에의해 지정된 문자 집합이 <code>str</code>의 쉬에 있다면 해당되는
	     * 문자를 삭제한후 문자열을 반환한다.<br>
	     * 만일 <code>stripChars</code>가 <code>null</code>인경우 stripChars는 빈
	     * 공백문자로 취급되어 문자열의 뒷부분에 빈 문자열을 삭제한다.
	     * <ul>
	     * <li>StringUtils.stripEnd(null, *) = null
	     * <li>StringUtils.stripEnd("", *) = ""
	     * <li>StringUtils.stripEnd("abc", "") = "abc"
	     * <li>StringUtils.stripEnd("abc", null) = "abc"
	     * <li>StringUtils.stripEnd(" abc", null) = " abc"
	     * <li>StringUtils.stripEnd("abc ", null) = "abc"
	     * <li>StringUtils.stripEnd(" abc ", null) = " abc"
	     * <li>StringUtils.stripEnd(" abcyx", "xyz") = " abc"
	     * </ul>
	     *
	     * @param str
	     *            문자열 뒷부분에 지정된 문자집합이 있을경우 삭제될 문자열
	     * @param stripChars
	     *            삭제할 문자집합, NUll은 공백문자로 인식하여 처리한다.
	     * @return
	     */
	    public static String stripEnd(String str, String stripChars) {
	        int end;
	        if (str == null || (end = str.length()) == 0) {
	            return str;
	        }

	        if (stripChars == null) {
	            while ((end != 0) && Character.isWhitespace(str.charAt(end - 1))) {
	                end--;
	            }
	        } else if (stripChars.length() == 0) {
	            return str;
	        } else {
	            while ((end != 0)
	                    && (stripChars.indexOf(str.charAt(end - 1)) != -1)) {
	                end--;
	            }
	        }
	        return str.substring(0, end);
	    }

	    // StripAll
	    // -----------------------------------------------------------------------
	    /**
	     * 주어진 모든 배열 요소의 앞뒤의 공백 문자를 제거한 결과값을 반환한다.<br>
	     * 배열이 <code>null</code>인경우 <code>null</code>을 반환하고, 비어있는 배열이라면 그대로 다시
	     * 그 배열을 반환한다.
	     * <ul>
	     * <li>StringUtils.stripAll(null) = null
	     * <li>StringUtils.stripAll([]) = []
	     * <li>StringUtils.stripAll(["abc", " abc"]) = ["abc", "abc"]
	     * <li>StringUtils.stripAll(["abc ", null]) = ["abc", null]
	     * </ul>
	     *
	     * @param strs
	     *            공백문자가 삭제될 문자열
	     * @return
	     */
	    public static String[] stripAll(String[] strs) {
	        return stripAll(strs, null);
	    }

	    /**
	     * 주어진 모든 배열 요소의 앞뒤의 지정된 문자(<code>stripChars</code> : 삭제해야할 문자의 집합)를 제거한
	     * 결과값을 반환한다.<br>
	     * 배열이 <code>null</code>인경우 <code>null</code>을 반환하고, 비어있는 배열이라면 그대로 다시
	     * 그 배열을 반환한다.<br>
	     * 삭제해야할 문자의 집합(<code>stripChars</code>)이 Null인경우 공백문자를 삭제하여 반환할것이다.
	     * <ul>
	     * <li>StringUtils.stripAll(null, *) = null
	     * <li>StringUtils.stripAll([], *) = []
	     * <li>StringUtils.stripAll(["abc", " abc"], null) = ["abc", "abc"]
	     * <li>StringUtils.stripAll(["abc ", null], null) = ["abc", null]
	     * <li>StringUtils.stripAll(["abc ", null], "yz") = ["abc ", null]
	     * <li>StringUtils.stripAll(["yabcz", null], "yz") = ["abc", null]
	     * </ul>
	     *
	     * @param strs
	     *            공백문자 또는 지정된 문자집합의 문자가 삭제될 문자열
	     * @param stripChars
	     *            삭제될 문자열
	     * @return
	     */
	    public static String[] stripAll(String[] strs, String stripChars) {
	        int strsLen;
	        if (strs == null || (strsLen = strs.length) == 0) {
	            return strs;
	        }
	        String[] newArr = new String[strsLen];
	        for (int i = 0; i < strsLen; i++) {
	            newArr[i] = strip(strs[i], stripChars);
	        }
	        return newArr;
	    }

	    // Equals
	    // -----------------------------------------------------------------------
	    /**
	     * 두개의 문자열을 대소문자를 구분하여 비교한다.<br>
	     * cf. : JDK의 String형의 equals()는 비교되는 피문자열이 null인경우 NullPointerException 예외를
	     * 발생시키지만 이 메소드는 예외상황은 발생시키지 않는다.
	     * <ul>
	     * <li>StringUtils.equals(null, null) = true
	     * <li>StringUtils.equals(null, &quot;abc&quot;) = false
	     * <li>StringUtils.equals(&quot;abc&quot;, null) = false
	     * <li>StringUtils.equals(&quot;abc&quot;, &quot;abc&quot;) = true
	     * <li>StringUtils.equals(&quot;abc&quot;, &quot;ABC&quot;) = false
	     * </ul>
	     *
	     * @see java.lang.String#equals(Object)
	     * @param str1
	     *            첫번째 문자열
	     * @param str2
	     *            두번째 문자열
	     * @return <code>true</code> if the Strings are equal, case sensitive, or
	     *         both <code>null</code>
	     */
	    public static boolean equals(String str1, String str2) {
	        return str1 == null ? str2 == null : str1.equals(str2);
	    }

	    /**
	     * 두개의 문자열을 대소문자를 구분하지 않고 비교한다.<br>
	     * cf. : JDK의 String형의 equals()는 비교되는 피문자열이 null인경우 NullPointerException 예외를
	     * 발생시키지만 이 메소드는 예외상황은 발생시키지 않는다.
	     * <ul>
	     * <li>StringUtils.equalsIgnoreCase(null, null) = true
	     * <li>StringUtils.equalsIgnoreCase(null, &quot;abc&quot;) = false
	     * <li>StringUtils.equalsIgnoreCase(&quot;abc&quot;, null) = false
	     * <li>StringUtils.equalsIgnoreCase(&quot;abc&quot;, &quot;abc&quot;) =
	     * true
	     * <li>StringUtils.equalsIgnoreCase(&quot;abc&quot;, &quot;ABC&quot;) =
	     * true
	     * </ul>
	     *
	     * @param str1
	     *            첫번째 문자열
	     * @param str2
	     *            두번째 문자열
	     * @return
	     */
	    public static boolean equalsIgnoreCase(String str1, String str2) {
	        return str1 == null ? str2 == null : str1.equalsIgnoreCase(str2);
	    }

	    // Contains
	    // -----------------------------------------------------------------------
	    /**
	     * 문자열(<code>str</code)에 주어진 문자(<code>searchChar</code)가 포함되어있는지 검사한다.<br>
	     * <ul>
	     * <li>StringUtils.contains(null, *)    = false
	     * <li>StringUtils.contains("", *)      = false
	     * <li>StringUtils.contains("abc", 'a') = true
	     * <li>StringUtils.contains("abc", 'z') = false
	     * </ul>
	     *
	     * @param str  검사할 문자열
	     * @param searchChar  검사 항목 문자
	     * @return
	     */
	    public static boolean contains(String str, char searchChar) {
	        if (isEmpty(str)) {
	            return false;
	        }
	        return str.indexOf(searchChar) >= 0;
	    }

	    /**
	     * 문자열(<code>str</code)에 주어진 문자열(<code>searchStr</code)이 포함되어있는지 검사한다.<br>
	     *
	     * <ul>
	     * <li>StringUtils.contains(null, *)     = false
	     * <li>StringUtils.contains(*, null)     = false
	     * <li>StringUtils.contains("", "")      = true
	     * <li>StringUtils.contains("abc", "")   = true
	     * <li>StringUtils.contains("abc", "a")  = true
	     * <li>StringUtils.contains("abc", "z")  = false
	     * </ul>
	     *
	     * @param str  검사할 문자열
	     * @param searchStr  검사 항목 문자열
	     * @return
	     */
	    public static boolean contains(String str, String searchStr) {
	        if (str == null || searchStr == null) {
	            return false;
	        }
	        return str.indexOf(searchStr) >= 0;
	    }

	    /**
	     * 첫번째로 주어진 문자열 매개변수(<code>str</code>)에 두번째 매개변수의 문자로만 구성되어있는지 검사한다.<br>
	     * <code>null</code>String은 <code>false</code>를 반환할 것이다.<br>
	     * 두번째 매개변수가 <code>null</code>인경우 <code>false</code>를 반환한다.<br>
	     * 빈 공백의 문자열은 ("") 항상 <code>true</code>값을 반환한다.
	     * <ul>
	     * <li>StringUtils.containsOnly(null, *) = false
	     * <li>StringUtils.containsOnly(*, null) = false
	     * <li>StringUtils.containsOnly(&quot;&quot;, *) = true
	     * <li>StringUtils.containsOnly(&quot;ab&quot;, '') = false
	     * <li>StringUtils.containsOnly(&quot;abab&quot;, 'abc') = true
	     * <li>StringUtils.containsOnly(&quot;ab1&quot;, 'abc') = false
	     * <li>StringUtils.containsOnly(&quot;abz&quot;, 'abc') = false
	     * </ul>
	     *
	     * @param str
	     *            검사할 문자열
	     * @param valid
	     *            유효한 문자인지 비교대상이될 문자집합
	     * @return
	     */
	    public static boolean containsOnly(String str, char[] valid) {
	        // All these pre-checks are to maintain API with an older version
	        if ((valid == null) || (str == null)) {
	            return false;
	        }
	        if (str.length() == 0) {
	            return true;
	        }
	        if (valid.length == 0) {
	            return false;
	        }
	        return indexOfAnyBut(str, valid) == -1;
	    }

	    /**
	     * 첫번째로 주어진 문자열 매개변수(<code>str</code>)에 두번째 매개변수의 문자열로만 구성되어있는지 검사한다.<br>
	     * <code>null</code>String은 <code>false</code>를 반환할 것이다.<br>
	     * 두번째 매개변수가 <code>null</code>인경우 <code>false</code>를 반환한다.<br>
	     * 빈 공백의 문자열은 ("") 항상 <code>true</code>값을 반환한다.
	     * <ul>
	     * <li> StringUtils.containsOnly(null, *) = false
	     * <li>StringUtils.containsOnly(*, null) = false
	     * <li>StringUtils.containsOnly(&quot;&quot;, *) = true
	     * <li>StringUtils.containsOnly(&quot;ab&quot;, &quot;&quot;) = false
	     * <li>StringUtils.containsOnly(&quot;abab&quot;, &quot;abc&quot;) = true
	     * <li>StringUtils.containsOnly(&quot;ab1&quot;, &quot;abc&quot;) = false
	     * <li>StringUtils.containsOnly(&quot;abz&quot;, &quot;abc&quot;) = false
	     * </ul>
	     *
	     * @param str
	     *            the String to check, may be null
	     * @param validChars
	     *            a String of valid chars, may be null
	     * @return true if it only contains valid chars and is non-null
	     * @since 2.0
	     */
	    public static boolean containsOnly(String str, String validChars) {
	        if (str == null || validChars == null) {
	            return false;
	        }
	        return containsOnly(str, validChars.toCharArray());
	    }

	    /**
	     * 문자열(<code>str</code)에 주어진 문자(<code>searchChar</code)가 포함되어있는지 않은지 검사한다.<br>
	     * 문자열(str)이 <code>null</code>이라면 <code>true</code>를 반환할것이다.<br>
	     * 유효검사 문자집합이 <code>null</code>이라면 <code>true</code>를 반환할것이다.<br>
	     * 문자열이 빈 공백문자("")라면 항상 <code>true</code>를 반환할것이다.
	     * <ul>
	     *       <li> StringUtils.containsNone(null, *)       = true
	     *       <li>StringUtils.containsNone(*, null)       = true
	     *       <li>StringUtils.containsNone(&quot;&quot;, *)         = true
	     *       <li>StringUtils.containsNone(&quot;ab&quot;, '')      = true
	     *       <li>StringUtils.containsNone(&quot;abab&quot;, 'xyz') = true
	     *       <li>StringUtils.containsNone(&quot;ab1&quot;, 'xyz')  = true
	     *       <li>StringUtils.containsNone(&quot;abz&quot;, 'xyz')  = false
	     * </ul>
	     *
	     * @param str 검사할 문자열
	     * @param invalidChars 유효한 문자집합
	     * @return
	     */
	    public static boolean containsNone(String str, char[] invalidChars) {
	        if (str == null || invalidChars == null) {
	            return true;
	        }
	        int strSize = str.length();
	        int validSize = invalidChars.length;
	        for (int i = 0; i < strSize; i++) {
	            char ch = str.charAt(i);
	            for (int j = 0; j < validSize; j++) {
	                if (invalidChars[j] == ch) {
	                    return false;
	                }
	            }
	        }
	        return true;
	    }

	    /**
	     * 문자열(<code>str</code)에 주어진 문자열(<code>invalidChars</code)가 포함되어있는지 않은지 검사한다.<br>
	     * 문자열(str)이 <code>null</code>이라면 <code>true</code>를 반환할것이다.<br>
	     * 유효검사 문자집합이 <code>null</code>이라면 <code>true</code>를 반환할것이다.<br>
	     * 문자열이 빈 공백문자("")라면 항상 <code>true</code>를 반환할것이다.
	     *
	     * <ul>
	     *     <li>StringUtils.containsNone(null, *)       = true
	     *     <li>StringUtils.containsNone(*, null)       = true
	     *     <li>StringUtils.containsNone(&quot;&quot;, *)         = true
	     *     <li> StringUtils.containsNone(&quot;ab&quot;, &quot;&quot;)      = true
	     *     <li>StringUtils.containsNone(&quot;abab&quot;, &quot;xyz&quot;) = true
	     *     <li>StringUtils.containsNone(&quot;ab1&quot;, &quot;xyz&quot;)  = true
	     *     <li>StringUtils.containsNone(&quot;abz&quot;, &quot;xyz&quot;)  = false
	     * </ul>
	     *
	     * @param str 검사할 문자열
	     * @param invalidChars 유효한 문자열
	     * @return
	     */
	    public static boolean containsNone(String str, String invalidChars) {
	        if (str == null || invalidChars == null) {
	            return true;
	        }
	        return containsNone(str, invalidChars.toCharArray());
	    }

	    // IndexOfAnyBut chars
	    // -----------------------------------------------------------------------
	    /**
	     * 주어진 문자열에서 두번째로 주어진 문자가 시작하는 첫번째 Index 값을 반환한다.<br>
	     * A <code>null</code> String will return <code>-1</code>. A
	     * <code>null</code> or zero length search array will return
	     * <code>-1</code>.<br>
	     * <ul>
	     * <li>StringUtils.indexOfAnyBut(null, *) = -1
	     * <li>StringUtils.indexOfAnyBut(&quot;&quot;, *) = -1
	     * <li>StringUtils.indexOfAnyBut(*, null) = -1
	     * <li>StringUtils.indexOfAnyBut(*, []) = -1
	     * <li>StringUtils.indexOfAnyBut(&quot;zzabyycdxx&quot;,'za') = 3
	     * <li>StringUtils.indexOfAnyBut(&quot;zzabyycdxx&quot;, '') = 0
	     * <li>StringUtils.indexOfAnyBut(&quot;aba&quot;, 'ab') = -1
	     * </ul>
	     *
	     * @param str
	     *            검사할 문자열
	     * @param searchChars
	     *            찾을 문자집합
	     * @return
	     */
	    public static int indexOfAnyBut(String str, char[] searchChars) {
	        if (isEmpty(str) || isEmpty(searchChars)) {
	            return -1;
	        }
	        outer: for (int i = 0; i < str.length(); i++) {
	            char ch = str.charAt(i);
	            for (int j = 0; j < searchChars.length; j++) {
	                if (searchChars[j] == ch) {
	                    continue outer;
	                }
	            }
	            return i;
	        }
	        return -1;
	    }

	    // Substring
	    // -----------------------------------------------------------------------
	    /**
	     * 주어진 문자열에대하여 substring을 수행한다. JDK String의 substring과는 다르게 exception를 발생하지
	     * 않는다.<br>
	     * 시작위치가 음수인경우 좌측에서 부터시작하여 지정된 숫자만큼의 문자를 되돌린다.<br>
	     * 시작위치가 문자열의 Index범위 밖에 있는경우 StringIndexOutOfBoundsException예외를 발생시키지않고 빈
	     * 공백문자를 되돌린다.<br>
	     * <ul>
	     * <li>StringUtils.substring(null, *) = null
	     * <li>StringUtils.substring("", *) = ""
	     * <li>StringUtils.substring("abc", 0) = "abc"
	     * <li>StringUtils.substring("abc", 2) = "c"
	     * <li>StringUtils.substring("abc", 4) = ""
	     * <li>StringUtils.substring("abc", -2) = "bc"
	     * <li>StringUtils.substring("abc", -4) = "abc"
	     * </ul>
	     *
	     * @param str
	     *            substring할 문자열
	     * @param start
	     *            문자열의 Position 인텍스
	     * @return
	     */
	    public static String substring(String str, int start) {
	        if (str == null) {
	            return null;
	        }

	        // handle negatives, which means last n characters
	        if (start < 0) {
	            start = str.length() + start; // remember start is negative
	        }

	        if (start < 0) {
	            start = 0;
	        }
	        if (start > str.length()) {
	            return EMPTY;
	        }

	        return str.substring(start);
	    }

	    /**
	     * 주어진 문자열에대하여 substring을 수행한다. JDK String의 substring과는 다르게 exception를 발생하지
	     * 않는다.<br>
	     * 시작위치나 끝위치가 음수인경우 좌측에서 부터시작하여 지정된 숫자만큼의 Offset위치로 사용된다.<br>
	     * 시작위치가 문자열의 Index범위 밖에 있는경우 StringIndexOutOfBoundsException예외를 발생시키지않고 빈
	     * 공백문자를 되돌린다.<br>
	     * <ul>
	     * <li>StringUtils.substring(null, *, *) = null
	     * <li>StringUtils.substring("", * , *) = "";
	     * <li>StringUtils.substring("abc", 0, 2) = "ab"
	     * <li>StringUtils.substring("abc", 2, 0) = ""
	     * <li>StringUtils.substring("abc", 2, 4) = "c"
	     * <li>StringUtils.substring("abc", 4, 6) = ""
	     * <li>StringUtils.substring("abc", 2, 2) = ""
	     * <li>StringUtils.substring("abc", -2, -1) = "b"
	     * <li>StringUtils.substring("abc", -4, 2) = "ab"
	     * </ul>
	     *
	     * @param str
	     *            substring할 문자열
	     * @param start
	     *            문자열의 시작 Position 인텍스, 음수인경우 좌측부터 Offset위치를 나타낸다.
	     * @param end
	     *            문자열의 끝 Position 인텍스, 음수인경우 좌측부터 Offset위치를 나타낸다.
	     * @return
	     */
	    public static String substring(String str, int start, int end) {
	        if (str == null) {
	            return null;
	        }

	        // handle negatives
	        if (end < 0) {
	            end = str.length() + end; // remember end is negative
	        }
	        if (start < 0) {
	            start = str.length() + start; // remember start is negative
	        }

	        // check length next
	        if (end > str.length()) {
	            end = str.length();
	        }

	        // if start is greater than end, return ""
	        if (start > end) {
	            return EMPTY;
	        }

	        if (start < 0) {
	            start = 0;
	        }
	        if (end < 0) {
	            end = 0;
	        }

	        return str.substring(start, end);
	    }

	    /**
	     * 첫번째 매개변수로 주어진 문자열에서 두번째 매개변수에 지정된 문자를 첫번째로 찾아서 찾아진 문자열의 앞부분만을
	     * substring한다.<br>
	     * <code>null</code>문자열의 입력은 <code>null</code>을 반환 할 것이다.<br>
	     * 빈 문자열("")의 입력은 빈 문자열을 반환할것이다. <code>null</code> separator문자는 첫번째로 입력된
	     * 문자열을 그대로 반환한다.
	     * <ul>
	     * <li>StringUtils.substringBefore(null, *) = null
	     * <li>StringUtils.substringBefore("", *) = ""
	     * <li>StringUtils.substringBefore("abc", "a") = ""
	     * <li>StringUtils.substringBefore("abcba", "b") = "a"
	     * <li>StringUtils.substringBefore("abc", "c") = "ab"
	     * <li>StringUtils.substringBefore("abc", "d") = "abc"
	     * <li>StringUtils.substringBefore("abc", "") = ""
	     * <li>StringUtils.substringBefore("abc", null) = "abc"
	     * </ul>
	     *
	     * @param str
	     *            substring할 문자열
	     * @param separator
	     *            구분 문자열(Substring하기위한 지점을 찾기위한 구분 문자열)
	     * @return
	     */
	    public static String substringBefore(String str, String separator) {
	        if (isEmpty(str) || separator == null) {
	            return str;
	        }
	        if (separator.length() == 0) {
	            return str;
	        }
	        int pos = str.indexOf(separator);
	        if (pos == -1) {
	            return str;
	        }
	        return str.substring(0, pos);
	    }

	    /**
	     * 첫번째 매개변수로 주어진 문자열에서 두번째 매개변수에 지정된 문자를 첫번째로 찾아서 찾아진 문자열의 우측(끝)부분만을
	     * substring한다.<br>
	     * <code>null</code>문자열의 입력은 <code>null</code>을 반환 할 것이다.<br>
	     * 빈 문자열("")의 입력은 빈 문자열을 반환할것이다. <code>null</code> separator문자는 첫번째로 입력된
	     * 문자열을 그대로 반환한다.
	     * <ul>
	     * <li>StringUtils.substringAfter(null, *) = null
	     * <li>StringUtils.substringAfter("", *) = ""
	     * <li>StringUtils.substringAfter(*, null) = ""
	     * <li>StringUtils.substringAfter("abc", "a") = "bc"
	     * <li>StringUtils.substringAfter("abcba", "b") = "cba"
	     * <li>StringUtils.substringAfter("abc", "c") = ""
	     * <li>StringUtils.substringAfter("abc", "d") = ""
	     * <li>StringUtils.substringAfter("abc", "") = "abc"
	     * </ul>
	     *
	     * @param str
	     *            substring할 문자열
	     * @param separator
	     *            구분 문자열(Substring하기위한 지점을 찾기위한 구분 문자열)
	     * @return
	     */
	    public static String substringAfter(String str, String separator) {
	        if (isEmpty(str)) {
	            return str;
	        }
	        if (separator == null) {
	            return str;
	        }
	        int pos = str.indexOf(separator);
	        if (pos == -1) {
	            return str;
	        }
	        return str.substring(pos + separator.length());
	    }

	    /**
	     * 첫번째 매개변수로 주어진 문자열에서 두번째 매개변수에 지정된 문자를 마지막으로 찾아진 문자열의 앞부분을 substring한다.<br>
	     * <code>null</code>문자열의 입력은 <code>null</code>을 반환 할 것이다.<br>
	     * 빈 문자열("")의 입력은 빈 문자열을 반환할것이다. <code>null</code> separator문자는 첫번째로 입력된
	     * 문자열을 그대로 반환한다.
	     * <ul>
	     * <li>StringUtils.substringBeforeLast(null, *) = null
	     * <li>StringUtils.substringBeforeLast("", *) = ""
	     * <li>StringUtils.substringBeforeLast("abcba", "b") = "abc"
	     * <li>StringUtils.substringBeforeLast("abc", "c") = "ab"
	     * <li>StringUtils.substringBeforeLast("a", "a") = ""
	     * <li>StringUtils.substringBeforeLast("a", "z") = "a"
	     * <li>StringUtils.substringBeforeLast("a", null) = "a"
	     * <li>StringUtils.substringBeforeLast("a", "") = "a"
	     * </ul>
	     *
	     * @param str
	     *            substring할 문자열
	     * @param separator
	     *            구분 문자열(Substring하기위한 지점을 찾기위한 구분 문자열)
	     * @return
	     */
	    public static String substringBeforeLast(String str, String separator) {
	        if (isEmpty(str) || isEmpty(separator)) {
	            return str;
	        }
	        int pos = str.lastIndexOf(separator);
	        if (pos == -1) {
	            return str;
	        }
	        return str.substring(0, pos);
	    }

	    /**
	     * 첫번째 매개변수로 주어진 문자열에서 두번째 매개변수에 지정된 문자를 마지막으로 찾아진 문자열의 뒷(좌측 또는 끝)부분을
	     * substring한다.<br>
	     * <code>null</code>문자열의 입력은 <code>null</code>을 반환 할 것이다.<br>
	     * 빈 문자열("")의 입력은 빈 문자열을 반환할것이다. <code>null</code> separator문자는 첫번째로 입력된
	     * 문자열을 그대로 반환한다.
	     * <ul>
	     * <li>StringUtils.substringAfterLast(null, *) = null
	     * <li>StringUtils.substringAfterLast("", *) = ""
	     * <li>StringUtils.substringAfterLast(*, "") = ""
	     * <li>StringUtils.substringAfterLast(*, null) = ""
	     * <li>StringUtils.substringAfterLast("abc", "a") = "bc"
	     * <li>StringUtils.substringAfterLast("abcba", "b") = "a"
	     * <li>StringUtils.substringAfterLast("abc", "c") = ""
	     * <li>StringUtils.substringAfterLast("a", "a") = ""
	     * <li>StringUtils.substringAfterLast("a", "z") = ""
	     * </ul>
	     *
	     * @param str
	     *            substring할 문자열
	     * @param separator
	     *            구분 문자열(Substring하기위한 지점을 찾기위한 구분 문자열)
	     * @return
	     */
	    public static String substringAfterLast(String str, String separator) {
	        if (isEmpty(str)) {
	            return str;
	        }
	        if (isEmpty(separator)) {
	            return EMPTY;
	        }
	        int pos = str.lastIndexOf(separator);
	        if (pos == -1) {
	            return str;
	        }
	        return str.substring(pos + separator.length());
	    }

	    /**
	     * 첫번째 매개변수로 주어진 문자열에서 두번째 매개변수로 주어진 문자열 사이에 있는 문자열을 Substring하여 반환한다.<br>
	     * 첫번째 또는 두번째 매개변수 <code>null</code>로 입력된 문자열은 <code>null</code>을
	     * 반환할것이다.
	     * <ul>
	     * <li>StringUtils.substringBetween(null, *) = null
	     * <li>StringUtils.substringBetween("", "") = ""
	     * <li>StringUtils.substringBetween("", "tag") = null
	     * <li>StringUtils.substringBetween("tagabctag", null) = null
	     * <li>StringUtils.substringBetween("tagabctag", "") = ""
	     * <li>StringUtils.substringBetween("tagabctag", "tag") = "abc"
	     * </ul>
	     *
	     * @param str
	     *            substring할 문자열
	     * @param tag
	     *            substring할 문자열의 구간을 지정하기위한 문자열(tag)
	     * @return
	     */
	    public static String substringBetween(String str, String tag) {
	        return substringBetween(str, tag, tag);
	    }

	    /**
	     * 첫번째 매개변수로 주어진 문자열에서 첫번째와 두번째 매개변수로 주어진 문자열 사이에 있는 문자열을 Substring하여 반환한다.<br>
	     * 첫번째 또는 두번째, 세번째 매개변수 <code>null</code>로 입력된 문자열은 <code>null</code>을
	     * 반환할것이다.<br>
	     * 두번째 또는 세번째 매개변수로 빈 공백문자로 주어진경우 빈 공백문자를 반환할것이다.
	     * <ul>
	     * <li>StringUtils.substringBetween(null, *, *) = null
	     * <li>StringUtils.substringBetween("", "", "") = ""
	     * <li>StringUtils.substringBetween("", "", "tag") = null
	     * <li>StringUtils.substringBetween("", "tag", "tag") = null
	     * <li>StringUtils.substringBetween("yabcz", null, null) = null
	     * <li>StringUtils.substringBetween("yabcz", "", "") = ""
	     * <li>StringUtils.substringBetween("yabcz", "y", "z") = "abc"
	     * <li>StringUtils.substringBetween("yabczyabcz", "y", "z") = "abc"
	     * </ul>
	     *
	     * @param str
	     *            substring할 문자열
	     * @param open
	     *            substring할 문자열의 시작 구간을 지정하기위한 문자열(tag)
	     * @param close
	     *            substring할 문자열의 끝 구간을 지정하기위한 문자열(tag)
	     * @return
	     */
	    public static String substringBetween(String str, String open, String close) {
	        if (str == null || open == null || close == null) {
	            return null;
	        }
	        int start = str.indexOf(open);
	        if (start != -1) {
	            int end = str.indexOf(close, start + open.length());
	            if (end != -1) {
	                return str.substring(start + open.length(), end);
	            }
	        }
	        return null;
	    }

	    // Left/Right/Mid
	    // -----------------------------------------------------------------------
	    /**
	     * 주어진 문자열에서 주어진 길이(len)만큼의 좌측부분의 문자들을 반환한다.<br>
	     * 주어진 길이가 유효하지않은 숫자이거나 null인경우 예외를 발생하지 않는다. 하지만 음수인경우 예외를 발생시킨다.<br>
	     * <ul>
	     * <li>StringUtils.left(null, *) = null
	     * <li>StringUtils.left(*, -ve) = &quot;&quot;
	     * <li>StringUtils.left(&quot;&quot;, *) = &quot;&quot;
	     * <li>StringUtils.left(&quot;abc&quot;, 0) = &quot;&quot;
	     * <li>StringUtils.left(&quot;abc&quot;, 2) = &quot;ab&quot;
	     * <li>StringUtils.left(&quot;abc&quot;, 4) = &quot;abc&quot;
	     * </ul>
	     *
	     * @param str
	     *            앞쪽의 지정된 길이만큼 문자를 얻을 문자열
	     * @param len
	     *            문자를 얻을 문자열 길이, 반드시 0 또는 양수이어야한다.
	     * @return
	     */
	    public static String left(String str, int len) {
	        if (str == null) {
	            return null;
	        }
	        if (len < 0) {
	            return EMPTY;
	        }
	        if (str.length() <= len) {
	            return str;
	        } else {
	            return str.substring(0, len);
	        }
	    }

	    /**
	     * 주어진 문자열에서 주어진 길이(len)만큼의 오른쪽(끝)부분의 문자들을 반환한다.<br>
	     * 주어진 길이가 유효하지않은 숫자이거나 null인경우 예외를 발생하지 않는다. 하지만 음수인경우 예외를 발생시킨다.<br>
	     * <ul>
	     * <li>StringUtils.right(null, *) = null
	     * <li>StringUtils.right(*, -ve) = &quot;&quot;
	     * <li>StringUtils.right(&quot;&quot;, *) = &quot;&quot;
	     * <li>StringUtils.right(&quot;abc&quot;, 0) = &quot;&quot;
	     * <li>StringUtils.right(&quot;abc&quot;, 2) = &quot;bc&quot;
	     * <li>StringUtils.right(&quot;abc&quot;, 4) = &quot;abc&quot;
	     * </ul>
	     *
	     * @param str
	     *            앞쪽의 지정된 길이만큼 문자를 얻을 문자열
	     * @param len
	     *            문자를 얻을 문자열 길이, 반드시 0 또는 양수이어야한다.
	     * @return
	     */
	    public static String right(String str, int len) {
	        if (str == null) {
	            return null;
	        }
	        if (len < 0) {
	            return EMPTY;
	        }
	        if (str.length() <= len) {
	            return str;
	        } else {
	            return str.substring(str.length() - len);
	        }
	    }

	    // Joining
	    // -----------------------------------------------------------------------
	    /**
	     * 주어진 배열을 하나의 문자열로 합처 반환한다.<br>
	     * 배열내의 Null객체 또는 empty문자열 은 빈문자열로서 처리된다.
	     * <ul>
	     * <li>StringUtils.join(null) = null
	     * <li>StringUtils.join([]) = &quot;&quot;
	     * <li>StringUtils.join([null]) = &quot;&quot;
	     * <li>StringUtils.join([&quot;a&quot;, &quot;b&quot;, &quot;c&quot;]) =
	     * &quot;abc&quot;
	     * <li>StringUtils.join([null, &quot;&quot;, &quot;a&quot;]) =
	     * &quot;a&quot;
	     * </ul>
	     *
	     * @param array
	     *            합처질 배열값들
	     * @return
	     */
	    public static String join(Object[] array) {
	        return join(array, null);
	    }

	    /**
	     * 주어진 배열을 하나의 문자열로 합처 반환한다.<br>
	     * 배열내의 Null객체 또는 empty문자열 은 빈문자열로서 처리된다.
	     * <ul>
	     * <li>StringUtils.join(null, *) = null
	     * <li>StringUtils.join([], *) = &quot;&quot;
	     * <li>StringUtils.join([null], *) = &quot;&quot;
	     * <li>StringUtils.join([&quot;a&quot;, &quot;b&quot;, &quot;c&quot;], ';') =
	     * &quot;a;b;c&quot;
	     * <li>StringUtils.join([&quot;a&quot;, &quot;b&quot;, &quot;c&quot;],
	     * null) = &quot;abc&quot;
	     * <li>StringUtils.join([null, &quot;&quot;, &quot;a&quot;], ';') =
	     * &quot;;;a&quot;
	     * </ul>
	     *
	     * @param array
	     *            합처질 배열값들
	     * @param separator
	     *            구분자로 사용될 문자(null갑은 ""로 처리된다)
	     * @return
	     */
	    public static String join(Object[] array, char separator) {
	        if (array == null) {
	            return null;
	        }
	        int arraySize = array.length;
	        int bufSize = (arraySize == 0 ? 0 : ((array[0] == null ? 16 : array[0]
	                .toString().length()) + 1)
	                * arraySize);
	        StringBuffer buf = new StringBuffer(bufSize);

	        for (int i = 0; i < arraySize; i++) {
	            if (i > 0) {
	                buf.append(separator);
	            }
	            if (array[i] != null) {
	                buf.append(array[i]);
	            }
	        }
	        return buf.toString();
	    }

	    /**
	     * 주어진 배열을 하나의 문자열로 합처 반환한다.<br>
	     * <code>null</code>구분자는 빈문자열("")과 동일하게 처리된다.
	     * <ul>
	     * <li>StringUtils.join(null, *) = null
	     * <li>StringUtils.join([], *) = &quot;&quot;
	     * <li>StringUtils.join([null], *) = &quot;&quot;
	     * <li>StringUtils.join([&quot;a&quot;, &quot;b&quot;, &quot;c&quot;],
	     * &quot;--&quot;) = &quot;a--b--c&quot;
	     * <li>StringUtils.join([&quot;a&quot;, &quot;b&quot;, &quot;c&quot;],
	     * null) = &quot;abc&quot;
	     * <li>StringUtils.join([&quot;a&quot;, &quot;b&quot;, &quot;c&quot;],
	     * &quot;&quot;) = &quot;abc&quot;
	     * <li>StringUtils.join([null, &quot;&quot;, &quot;a&quot;], ',') =
	     * &quot;,,a&quot;
	     * </ul>
	     *
	     * @param array
	     *            합처질 배열값들
	     * @param separator
	     *            구분자로 사용될 문자열(null갑은 ""로 처리된다)
	     * @return
	     */
	    public static String join(Object[] array, String separator) {
	        if (array == null) {
	            return null;
	        }
	        if (separator == null) {
	            separator = EMPTY;
	        }
	        int arraySize = array.length;

	        int bufSize = ((arraySize == 0) ? 0
	                : arraySize
	                        * ((array[0] == null ? 16 : array[0].toString()
	                                .length()) + separator.length()));

	        StringBuffer buf = new StringBuffer(bufSize);

	        for (int i = 0; i < arraySize; i++) {
	            if (i > 0) {
	                buf.append(separator);
	            }
	            if (array[i] != null) {
	                buf.append(array[i]);
	            }
	        }
	        return buf.toString();
	    }

	    /**
	     * 주어진 <code>Iterator</code>객체에 대한 내용을 합처 하나의 String으로 반환한다.<br>
	     * iteration의 Null객체또는 빈문자열 은 빈 문자열로 처리된다.<br>
	     * 예제참조 : {@link #join(Object[],char)}.
	     *
	     * @param iterator
	     *            합처질<code>Iterator</code>객체
	     * @param separator
	     *            분리 문자로 사용될 문자
	     * @return
	     */
	    public static String join(Iterator iterator, char separator) {
	        if (iterator == null) {
	            return null;
	        }
	        StringBuffer buf = new StringBuffer(256); // Java default is 16,
	        // probably too small
	        while (iterator.hasNext()) {
	            Object obj = iterator.next();
	            if (obj != null) {
	                buf.append(obj);
	            }
	            if (iterator.hasNext()) {
	                buf.append(separator);
	            }
	        }
	        return buf.toString();
	    }

	    /**
	     * 주어진 <code>Iterator</code>객체에 대한 내용을 합처 하나의 String으로 반환한다.<br>
	     * <code>null</code>구분자는 빈문자열("")로서 간주되어 처리된다.<br>
	     * 예제참조: {@link #join(Object[],String)}.
	     *
	     * @param iterator
	     *            합처질<code>Iterator</code>객체
	     * @param separator
	     *            분리 문자로 사용될 문자
	     * @return
	     */
	    public static String join(Iterator iterator, String separator) {
	        if (iterator == null) {
	            return null;
	        }
	        StringBuffer buf = new StringBuffer(256); // Java default is 16,
	        // probably too small
	        while (iterator.hasNext()) {
	            Object obj = iterator.next();
	            if (obj != null) {
	                buf.append(obj);
	            }
	            if ((separator != null) && iterator.hasNext()) {
	                buf.append(separator);
	            }
	        }
	        return buf.toString();
	    }

	    // Delete
	    // -----------------------------------------------------------------------
	    /**
	     * 주어진 문자열에서 공백문자(Tab포함)를 삭제한 결과를 반환한다.
	     * <ul>
	     * <li>StringUtils.deleteWhitespace(null) = null
	     * <li>StringUtils.deleteWhitespace(&quot;&quot;) = &quot;&quot;
	     * <li>StringUtils.deleteWhitespace(&quot;abc&quot;) = &quot;abc&quot;
	     * <li>StringUtils.deleteWhitespace(&quot; ab c &quot;) = &quot;abc&quot;
	     * </ul>
	     *
	     * @param str
	     *            빈공백문자를 삭제할 문자열
	     * @return
	     */
	    public static String deleteWhitespace(String str) {
	        if (isEmpty(str)) {
	            return str;
	        }
	        int sz = str.length();
	        char[] chs = new char[sz];
	        int count = 0;
	        for (int i = 0; i < sz; i++) {
	            if (!Character.isWhitespace(str.charAt(i))) {
	                chs[count++] = str.charAt(i);
	            }
	        }
	        if (count == sz) {
	            return str;
	        }
	        return new String(chs, 0, count);
	    }

	    // Remove
	    // -----------------------------------------------------------------------
	    /**
	     * 주어진 문자열(str)에서 두번째 매개변수로 주어진 문자열로 시작하면 두번째 매개변수로 주어진 문자열을 삭제한 결과를 반환한다.<br>
	     * 소스문자열이 <code>null</code>인경우 <code>null</code>을 반환한다.<br>
	     * 소스문자열이 빈공백 문자("")인경우 빈 공백문자를 되돌린다.<br>
	     * 두번째 매개변수가 <code>null</code>인경우 첫번째 매개변수를 그대로 반환할 것이다.<br>
	     * <ul>
	     * <li>StringUtils.removeStart(null, *) = null
	     * <li>StringUtils.removeStart(&quot;&quot;, *) = &quot;&quot;
	     * <li>StringUtils.removeStart(*, null) = *
	     * <li>StringUtils.removeStart(&quot;www.domain.com&quot;,
	     * &quot;www.&quot;) = &quot;domain.com&quot;
	     * <li>StringUtils.removeStart(&quot;domain.com&quot;, &quot;www.&quot;) =
	     * &quot;domain.com&quot;
	     * <li>StringUtils.removeStart(&quot;www.domain.com&quot;,
	     * &quot;domain&quot;) = &quot;www.domain.com&quot;
	     * <li>StringUtils.removeStart(&quot;abc&quot;, &quot;&quot;) =
	     * &quot;abc&quot;
	     * </ul>
	     *
	     * @param str
	     *            작업할 문자열
	     * @param remove
	     *            찾아서 제거할 문자열
	     * @return
	     */
	    public static String removeStart(String str, String remove) {
	        if (isEmpty(str) || isEmpty(remove)) {
	            return str;
	        }
	        if (str.startsWith(remove)) {
	            return str.substring(remove.length());
	        }
	        return str;
	    }

	    /**
	     * 주어진 문자열(str)에서 두번째 매개변수로 주어진 문자열로 끝나면 두번째 매개변수로 주어진 문자열을 삭제한 결과를 반환한다.<br>
	     * 소스문자열이 <code>null</code>인경우 <code>null</code>을 반환한다.<br>
	     * 소스문자열이 빈공백 문자("")인경우 빈 공백문자를 되돌린다.<br>
	     * 두번째 매개변수가 <code>null</code>인경우 첫번째 매개변수를 그대로 반환할 것이다.<br>
	     * <ul>
	     * <li>StringUtils.removeEnd(null, *) = null
	     * <li>StringUtils.removeEnd(&quot;&quot;, *) = &quot;&quot;
	     * <li>StringUtils.removeEnd(*, null) = *
	     * <li>StringUtils.removeEnd(&quot;www.domain.com&quot;, &quot;.com.&quot;) =
	     * &quot;www,domain&quot;
	     * <li>StringUtils.removeEnd(&quot;www.domain.com&quot;, &quot;.com&quot;) =
	     * &quot;www.domain&quot;
	     * <li>StringUtils.removeEnd(&quot;www.domain.com&quot;,
	     * &quot;domain&quot;) = &quot;www.domain.com&quot;
	     * <li>StringUtils.removeEnd(&quot;abc&quot;, &quot;&quot;) =
	     * &quot;abc&quot;
	     * </ul>
	     *
	     * @param str
	     *            작업할 문자열
	     * @param remove
	     *            찾아서 제거할 문자열
	     * @return
	     */
	    public static String removeEnd(String str, String remove) {
	        if (isEmpty(str) || isEmpty(remove)) {
	            return str;
	        }
	        if (str.endsWith(remove)) {
	            return str.substring(0, str.length() - remove.length());
	        }
	        return str;
	    }

	    /**
	     * 주어진 문자열(str)에서 두번째 매개변수로 주어진 문자열과 일치하는 부분이 있으면 두번째 매개변수로 주어진 문자열을 삭제한 결과를
	     * 반환한다.<br>
	     * 소스문자열이 <code>null</code>인경우 <code>null</code>을 반환한다.<br>
	     * 소스문자열이 빈공백 문자("")인경우 빈 공백문자를 되돌린다.<br>
	     * 두번째 매개변수가 <code>null</code>인경우 첫번째 매개변수를 그대로 반환할 것이다.<br>
	     * <ul>
	     * <li>StringUtils.remove(null, *) = null
	     * <li>StringUtils.remove(&quot;&quot;, *) = &quot;&quot;
	     * <li>StringUtils.remove(*, null) = *
	     * <li>StringUtils.remove(*, &quot;&quot;) = *
	     * <li>StringUtils.remove(&quot;queued&quot;, &quot;ue&quot;) =
	     * &quot;qd&quot;
	     * <li>StringUtils.remove(&quot;queued&quot;, &quot;zz&quot;) =
	     * &quot;queued&quot;
	     * </ul>
	     *
	     * @param str
	     *            작업할 문자열
	     * @param remove
	     *            찾아서 제거할 문자열
	     * @return
	     */
	    public static String remove(String str, String remove) {
	        if (isEmpty(str) || isEmpty(remove)) {
	            return str;
	        }
	        return replace(str, remove, "", -1);
	    }

	    /**
	     * 주어진 문자열(str)에서 두번째 매개변수로 주어진 문자와 일치하는 부분이 있으면 두번째 매개변수로 주어진 문자들을 모두 삭제한
	     * 결과를 반환한다.<br>
	     * 소스문자열이 <code>null</code>인경우 <code>null</code>을 반환한다.<br>
	     * 소스문자열이 빈공백 문자("")인경우 빈 공백문자를 되돌린다.<br>
	     * 두번째 매개변수가 <code>null</code>인경우 첫번째 매개변수를 그대로 반환할 것이다.<br>
	     * <ul>
	     * <li>StringUtils.remove(null, *) = null
	     * <li>StringUtils.remove(&quot;&quot;, *) = &quot;&quot;
	     * <li>StringUtils.remove(&quot;queued&quot;, 'u') = &quot;qeed&quot;
	     * <li>StringUtils.remove(&quot;queued&quot;, 'z') = &quot;queued&quot;
	     * </ul>
	     *
	     * @param str
	     *            작업할 문자열
	     * @param remove
	     *            찾아서 제거할 문자
	     */
	    public static String remove(String str, char remove) {
	        if (isEmpty(str) || str.indexOf(remove) == -1) {
	            return str;
	        }
	        char[] chars = str.toCharArray();
	        int pos = 0;
	        for (int i = 0; i < chars.length; i++) {
	            if (chars[i] != remove) {
	                chars[pos++] = chars[i];
	            }
	        }
	        return new String(chars, 0, pos);
	    }

	    // Replacing
	    // -----------------------------------------------------------------------
	    /**
	     * 첫번째 매개변수의 문자열에서 두번째 매개변수의 문자열과 첫번째로 일치하는 문자열을 세번째 매개변수의 문자열로 한번만 교체한다.<br>
	     * <ul>
	     * <li>StringUtils.replaceOnce(null, *, *) = null
	     * <li>StringUtils.replaceOnce("", *, *) = ""
	     * <li>StringUtils.replaceOnce("any", null, *) = "any"
	     * <li>StringUtils.replaceOnce("any", *, null) = "any"
	     * <li>StringUtils.replaceOnce("any", "", *) = "any"
	     * <li>StringUtils.replaceOnce("aba", "a", null) = "aba"
	     * <li>StringUtils.replaceOnce("aba", "a", "") = "ba"
	     * <li>StringUtils.replaceOnce("aba", "a", "z") = "zba"
	     * </ul>
	     *
	     * @param text
	     *            작업할 문자열
	     * @param repl
	     *            찾을 문자열
	     * @param with
	     *            교체할 문자열
	     * @return
	     */
	    public static String replaceOnce(String text, String repl, String with) {
	        return replace(text, repl, with, 1);
	    }

	    /**
	     * 첫번째 매개변수의 문자열에서 두번째 매개변수의 문자열과 일치하는 모든 문자열을 세번째 매개변수의 문자열로 모두 교체한다.<br>
	     * <ul>
	     * <li>StringUtils.replace(null, *, *) = null
	     * <li>StringUtils.replace("", *, *) = ""
	     * <li>StringUtils.replace("any", null, *) = "any"
	     * <li>StringUtils.replace("any", *, null) = "any"
	     * <li>StringUtils.replace("any", "", *) = "any"
	     * <li>StringUtils.replace("aba", "a", null) = "aba"
	     * <li>StringUtils.replace("aba", "a", "") = "b"
	     * <li>StringUtils.replace("aba", "a", "z") = "zbz"
	     * </ul>
	     *
	     * @param text
	     *            작업할 문자열
	     * @param repl
	     *            찾을 문자열
	     * @param with
	     *            교체할 문자열
	     * @return
	     */
	    public static String replace(String text, String repl, String with) {
	        return replace(text, repl, with, -1);
	    }

	    /**
	     * 첫번째 매개변수의 문자열에서 두번째 매개변수의 문자열과 일치하는 문자열을 세번째 매개변수의 문자열로 앞에서 부터시작하여 max로
	     * 지정된 횟수만큼 교체한다. 만일 횟수가 -1인경우 교체횟수에 제한이 없음을 의미한다.<br>
	     * <ul>
	     * <li>StringUtils.replace(null, *, *, *) = null
	     * <li>StringUtils.replace("", *, *, *) = ""
	     * <li>StringUtils.replace("any", null, *, *) = "any"
	     * <li>StringUtils.replace("any", *, null, *) = "any"
	     * <li>StringUtils.replace("any", "", *, *) = "any"
	     * <li>StringUtils.replace("any", *, *, 0) = "any"
	     * <li>StringUtils.replace("abaa", "a", null, -1) = "abaa"
	     * <li>StringUtils.replace("abaa", "a", "", -1) = "b"
	     * <li>StringUtils.replace("abaa", "a", "z", 0) = "abaa"
	     * <li>StringUtils.replace("abaa", "a", "z", 1) = "zbaa"
	     * <li>StringUtils.replace("abaa", "a", "z", 2) = "zbza"
	     * <li>StringUtils.replace("abaa", "a", "z", -1) = "zbzz"
	     * </ul>
	     *
	     * @param text
	     *            작업할 문자열
	     * @param repl
	     *            찾을 문자열
	     * @param with
	     *            교체할 문자열
	     * @param max
	     *            최대 교체할 횟수, <code>-1</code>인경우 무제한
	     * @return
	     */
	    public static String replace(String text, String repl, String with, int max) {
	        if (text == null || isEmpty(repl) || with == null || max == 0) {
	            return text;
	        }

	        StringBuffer buf = new StringBuffer(text.length());
	        int start = 0, end = 0;
	        while ((end = text.indexOf(repl, start)) != -1) {
	            buf.append(text.substring(start, end)).append(with);
	            start = end + repl.length();

	            if (--max == 0) {
	                break;
	            }
	        }
	        buf.append(text.substring(start));
	        return buf.toString();
	    }

	    // Replace, character based
	    // -----------------------------------------------------------------------
	    /**
	     * 첫번째 매개변수의 문자열에서 두번째 매개변수의 문자와 일치하는 모든 문자를 세번째 매개변수의 문자로 모두 교체한다.<br>
	     * 첫번째 매개변수가 <code>null</code>인경우 <code>null</code>을 반환할것이다.<br>
	     * 빈 공백문자열("")는 빈 공백문자열을 반환할것이다.
	     * </p>
	     * <ul>
	     * <li>StringUtils.replaceChars(null, *, *) = null
	     * <li>StringUtils.replaceChars("", *, *) = ""
	     * <li>StringUtils.replaceChars("abcba", 'b', 'y') = "aycya"
	     * <li>StringUtils.replaceChars("abcba", 'z', 'y') = "abcba"
	     * </ul>
	     *
	     * @param str
	     *            작업할 문자열
	     * @param searchChar
	     *            찾을 문자
	     * @param replaceChar
	     *            교체할 문자
	     * @return
	     */
	    public static String replaceChars(String str, char searchChar,
	            char replaceChar) {
	        if (str == null) {
	            return null;
	        }
	        return str.replace(searchChar, replaceChar);
	    }

	    // Character Tests
	    // -----------------------------------------------------------------------
	    /**
	     * 주어진 문자열이 알파벳(공백문자포함)으로 구성되어있는지 검사한다.(유니코드 문자인지를 검사)<br>
	     * <code>null</code>이 입력되었을경우 <code>false</code>를 리턴할것이며. 빈문자열일 경우("")
	     * <code>true</code>를 리턴할것이다.
	     * <ul>
	     * <li>StringUtils.isAlpha(null) = false
	     * <li>StringUtils.isAlpha(&quot;&quot;) = true
	     * <li>StringUtils.isAlpha(&quot; &quot;) = false
	     * <li>StringUtils.isAlpha(&quot;abc&quot;) = true
	     * <li>StringUtils.isAlpha(&quot;ab2c&quot;) = false
	     * <li>StringUtils.isAlpha(&quot;ab-c&quot;) = false
	     * </ul>
	     *
	     * @param str
	     *            체크하려는 문자열
	     * @return
	     */
	    public static boolean isAlpha(String str) {
	        if (str == null) {
	            return false;
	        }
	        int sz = str.length();
	        for (int i = 0; i < sz; i++) {
	            if (Character.isLetter(str.charAt(i)) == false) {
	                return false;
	            }
	        }
	        return true;
	    }

	    /**
	     * 주어진 문자열이 유니코드문자(영문또는 스페이스문자(' '))인지를 검사한다.<br>
	     * <code>null</code>값은 <code>false</code>값을 반활할것이며, 빈 문자열은("")
	     * <code>true</code>를 반환할것이다.
	     * <ul>
	     * <li>StringUtils.isAlphaSpace(null) = false
	     * <li>StringUtils.isAlphaSpace(&quot;&quot;) = true
	     * <li>StringUtils.isAlphaSpace(&quot; &quot;) = true
	     * <li>StringUtils.isAlphaSpace(&quot;abc&quot;) = true
	     * <li>StringUtils.isAlphaSpace(&quot;ab c&quot;) = true
	     * <li>StringUtils.isAlphaSpace(&quot;ab2c&quot;) = false
	     * <li>StringUtils.isAlphaSpace(&quot;ab-c&quot;) = false
	     * </ul>
	     *
	     * @param str
	     *            체크하려는 문자열
	     * @return
	     */
	    public static boolean isAlphaSpace(String str) {
	        if (str == null) {
	            return false;
	        }
	        int sz = str.length();
	        for (int i = 0; i < sz; i++) {
	            if ((Character.isLetter(str.charAt(i)) == false)
	                    && (str.charAt(i) != ' ')) {
	                return false;
	            }
	        }
	        return true;
	    }

	    /**
	     * 주어진 문자열이 숫자나 영문으로 구성되어있는지 검사한다.<br>
	     * <code>null</code>값은 <code>false</code>값을 반환할것이다. 빈문자열("")은
	     * <code>true</code>를 반환할것이다.
	     * <ul>
	     * <li>StringUtils.isAlphanumeric(null) = false
	     * <li>StringUtils.isAlphanumeric(&quot;&quot;) = true
	     * <li>StringUtils.isAlphanumeric(&quot; &quot;) = false
	     * <li>StringUtils.isAlphanumeric(&quot;abc&quot;) = true
	     * <li>StringUtils.isAlphanumeric(&quot;ab c&quot;) = false
	     * <li>StringUtils.isAlphanumeric(&quot;ab2c&quot;) = true
	     * <li>StringUtils.isAlphanumeric(&quot;ab-c&quot;) = false
	     * </ul>
	     *
	     * @param str
	     *            체크하려는 문자열
	     * @return
	     */
	    public static boolean isAlphanumeric(String str) {
	        if (str == null) {
	            return false;
	        }
	        int sz = str.length();
	        for (int i = 0; i < sz; i++) {
	            if (Character.isLetterOrDigit(str.charAt(i)) == false) {
	                return false;
	            }
	        }
	        return true;
	    }

	    /**
	     * 체크하려는 문자열이 영문이나, 숫자 또는 공백문자(<code>' '</code>) 인지를 검사한다.<br>
	     * <code>null</code>값은 <code>false</code>를 반환할것이다. 빈문자열은("")
	     * <code>true</code>를 반환할것이다.
	     * <ul>
	     * <li>StringUtils.isAlphanumeric(null) = false
	     * <li>StringUtils.isAlphanumeric(&quot;&quot;) = true
	     * <li>StringUtils.isAlphanumeric(&quot; &quot;) = true
	     * <li>StringUtils.isAlphanumeric(&quot;abc&quot;) = true
	     * <li>StringUtils.isAlphanumeric(&quot;ab c&quot;) = true
	     * <li>StringUtils.isAlphanumeric(&quot;ab2c&quot;) = true
	     * <li>StringUtils.isAlphanumeric(&quot;ab-c&quot;) = false
	     * </ul>
	     *
	     * @param str
	     *            체크하려는 문자열
	     * @return
	     */
	    public static boolean isAlphanumericSpace(String str) {
	        if (str == null) {
	            return false;
	        }
	        int sz = str.length();
	        for (int i = 0; i < sz; i++) {
	            if ((Character.isLetterOrDigit(str.charAt(i)) == false)
	                    && (str.charAt(i) != ' ')) {
	                return false;
	            }
	        }
	        return true;
	    }

	    /**
	     * 체크하려는 문자열이 숫자로 구성되어있는지 검사한다.(소수점이 있는 수는 숫자가 아니므로 false를 반환할것이다.<br>
	     * <code>null</code>값은 <code>false</code>를 반환할것이다. 빈 문자열("")은
	     * <code>true</code>값을 반환할것이다.
	     * <ul>
	     * <li>StringUtils.isNumeric(null) = false
	     * <li>StringUtils.isNumeric(&quot;&quot;) = true
	     * <li>StringUtils.isNumeric(&quot; &quot;) = false
	     * <li>StringUtils.isNumeric(&quot;123&quot;) = true
	     * <li>StringUtils.isNumeric(&quot;12 3&quot;) = false
	     * <li>StringUtils.isNumeric(&quot;ab2c&quot;) = false
	     * <li>StringUtils.isNumeric(&quot;12-3&quot;) = false
	     * <li>StringUtils.isNumeric(&quot;12.3&quot;) = false
	     * </ul>
	     *
	     * @param str
	     *            체크하려는 문자열
	     * @return
	     */
	    public static boolean isNumeric(String str) {
	        if (str == null) {
	            return false;
	        }
	        int sz = str.length();
	        for (int i = 0; i < sz; i++) {
	            if (Character.isDigit(str.charAt(i)) == false) {
	                return false;
	            }
	        }
	        return true;
	    }

	    /**
	     * 체크하려는 문자열이 오직 숫자또는 공백문자(<code>' '</code>)로 구성되어있는지 검사한다. (소수점이 있는 수는
	     * 숫자가 아니므로 false를 반환할것이다.<br>
	     * <code>null</code>값은 <code>false</code>를 반환할것이다. 빈 문자열("")은
	     * <code>true</code>값을 반환할것이다.
	     * <ul>
	     * <li>StringUtils.isNumeric(null) = false
	     * <li>StringUtils.isNumeric(&quot;&quot;) = true
	     * <li>StringUtils.isNumeric(&quot; &quot;) = true
	     * <li>StringUtils.isNumeric(&quot;123&quot;) = true
	     * <li>StringUtils.isNumeric(&quot;12 3&quot;) = true
	     * <li>StringUtils.isNumeric(&quot;ab2c&quot;) = false
	     * <li>StringUtils.isNumeric(&quot;12-3&quot;) = false
	     * <li>StringUtils.isNumeric(&quot;12.3&quot;) = false
	     * </ul>
	     *
	     * @param str
	     *            체크하려는 문자열
	     * @return
	     */
	    public static boolean isNumericSpace(String str) {
	        if (str == null) {
	            return false;
	        }
	        int sz = str.length();
	        for (int i = 0; i < sz; i++) {
	            if ((Character.isDigit(str.charAt(i)) == false)
	                    && (str.charAt(i) != ' ')) {
	                return false;
	            }
	        }
	        return true;
	    }

	    /**
	     * 체크하려는 문자열이 공백(whitespace)으로 구성되어있는지 검사한다.<br>
	     * <code>null</code>값은 <code>false</code>를 반환할것이다. 빈 문자열("")은
	     * <code>true</code>값을 반환할것이다.
	     * <ul>
	     * <li>StringUtils.isWhitespace(null) = false
	     * <li>StringUtils.isWhitespace(&quot;&quot;) = true
	     * <li>StringUtils.isWhitespace(&quot; &quot;) = true
	     * <li>StringUtils.isWhitespace(&quot;abc&quot;) = false
	     * <li>StringUtils.isWhitespace(&quot;ab2c&quot;) = false
	     * <li>StringUtils.isWhitespace(&quot;ab-c&quot;) = false
	     * </ul>
	     *
	     * @param str
	     *            체크하려는 문자열
	     * @return
	     */
	    public static boolean isWhitespace(String str) {
	        if (str == null) {
	            return false;
	        }
	        int sz = str.length();
	        for (int i = 0; i < sz; i++) {
	            if ((Character.isWhitespace(str.charAt(i)) == false)) {
	                return false;
	            }
	        }
	        return true;
	    }

	    // Defaults
	    // -----------------------------------------------------------------------
	    /**
	     * 체크하려는 문자열이 null인경우 기본 문자("")를 반환 하며, null이 아닌경우 원 값을 다시 반환한다.<br>
	     * <ul>
	     * <li>StringUtils.defaultString(null) = &quot;&quot;
	     * <li>StringUtils.defaultString(&quot;&quot;) = &quot;&quot;
	     * <li>StringUtils.defaultString(&quot;bat&quot;) = &quot;bat&quot;
	     * </ul>
	     *
	     * @see String#valueOf(Object)
	     * @param str
	     *            체크하려는 문자열
	     * @return
	     */
	    public static String defaultString(String str) {
	        return str == null ? EMPTY : str;
	    }

	    /**
	     * 체크하려는 문자열이 null인경우 기본 문자(<code>defaultStr</code>)를 반환 하며, null이 아닌경우
	     * 원 값을 다시 반환한다.<br>
	     * <ul>
	     * <li>StringUtils.defaultString(null, &quot;NULL&quot;) = &quot;NULL&quot;
	     * <li>StringUtils.defaultString(&quot;&quot;, &quot;NULL&quot;) =
	     * &quot;&quot;
	     * <li>StringUtils.defaultString(&quot;bat&quot;, &quot;NULL&quot;) =
	     * &quot;bat&quot;
	     * </ul>
	     *
	     * @see String#valueOf(Object)
	     * @param str
	     *            체크하려는 문자열
	     * @param defaultStr
	     *            기본 문자열 지정, 만일 입력값이<code>null</code>인경우 null을 반환할것이다.
	     * @return
	     */
	    public static String defaultString(String str, String defaultStr) {
	        return str == null ? defaultStr : str;
	    }

	    /**
	     * 체크하려는 문자열이 빈문자열이거나<code>null</code>인경우 지정된 <code>defaultStr</code>값을
	     * 반환하며 아닌경우 본 문자열을 반환한다.<br>
	     * <ul>
	     * <li>StringUtils.defaultIfEmpty(null, &quot;NULL&quot;) =
	     * &quot;NULL&quot;
	     * <li>StringUtils.defaultIfEmpty(&quot;&quot;, &quot;NULL&quot;) =
	     * &quot;NULL&quot;
	     * <li>StringUtils.defaultIfEmpty(&quot;bat&quot;, &quot;NULL&quot;) =
	     * &quot;bat&quot;
	     * </ul>
	     *
	     * @see StringUtils#defaultString(String, String)
	     * @param str
	     *            체크하려는 문자열
	     * @param defaultStr
	     *            기본 문자열 지정, 기본 지정 문자열이 빈문자이거나("") <code>null</code>인경우
	     *            null값을 반환할것이다.
	     * @return
	     */
	    public static String defaultIfEmpty(String str, String defaultStr) {
	        return isEmpty(str) ? defaultStr : str;
	    }

	    // Reversing
	    // -----------------------------------------------------------------------
	    /**
	     * 문자열을 역순으로 재배열한 문자열을 반환환다.{@link StringBuffer#reverse()}.<br>
	     * <code>null</code>인 값의 경우 <code>null</code>값을 반환할것이다.
	     * <ul>
	     * <li>StringUtils.reverse(null) = null
	     * <li>StringUtils.reverse(&quot;&quot;) = &quot;&quot;
	     * <li>StringUtils.reverse(&quot;bat&quot;) = &quot;tab&quot;
	     * </ul>
	     *
	     * @param str
	     *            역순으로 재 배열하려는 문자열
	     * @return
	     */
	    public static String reverse(String str) {
	        if (str == null) {
	            return null;
	        }
	        return new StringBuffer(str).reverse().toString();
	    }

	    /**
	     * 배열을 역순으로 재배열한 문자열을 반환환다.<br>
	     *
	     * @param array
	     *            역순으로 재 배열하려는 배열
	     */
	    public static void reverse(Object[] array) {
	        if (array == null) {
	            return;
	        }
	        int i = 0;
	        int j = array.length - 1;
	        Object tmp;
	        while (j > i) {
	            tmp = array[j];
	            array[j] = array[i];
	            array[i] = tmp;
	            j--;
	            i++;
	        }
	    }

	    /**
	     * 지정된 문자의 구분에의한 문자열을 역순으로 재배열한 문자열을 반환한다.<br>
	     * 구분 문자사이에있는 문자열은 역순으로 재배열되지 않는다.그리하여 java.lang.String는 String.lang.java형태로
	     * 재 배열될것이다. (구분자가<code>'.'</code>인 경우).
	     * <ul>
	     * <li>StringUtils.reverseDelimited(null, *) = null
	     * <li>StringUtils.reverseDelimited(&quot;&quot;, *) = &quot;&quot;
	     * <li>StringUtils.reverseDelimited(&quot;a.b.c&quot;, 'x') =
	     * &quot;a.b.c&quot;
	     * <li>StringUtils.reverseDelimited(&quot;a.b.c&quot;, &quot;.&quot;) =
	     * &quot;c.b.a&quot;
	     * </ul>
	     *
	     * @param str
	     *            체크하려는 문자열
	     * @param separatorChar
	     *            구분자 지정
	     * @return
	     */
	    public static String reverseDelimited(String str, char separatorChar) {
	        if (str == null) {
	            return null;
	        }
	        // could implement manually, but simple way is to reuse other,
	        // probably slower, methods.
	        String[] strs = split(str, separatorChar);
	        reverse(strs);
	        return join(strs, separatorChar);
	    }

	    // Abbreviating
	    // -----------------------------------------------------------------------
	    /**
	     * 생략 부호(...)와 함께 문자열을 줄여주는 메소드이다. "Now is the time for all good men"형태의
	     * 문자열을 "Now is the time for..."형태로 되돌려준다.<br>
	     * 특이사항:
	     * <ul>
	     * <li>만일 <code>str</code>가 <code>maxWidth</code>문자열 길이보다 작다면 주어진
	     * 문자열을 다시 리턴한다.</li>
	     * <li>만일 <code>maxWidth</code>가 <code>4</code>보다 작다면
	     * <code>IllegalArgumentException</code>예외상황을 발생시킨다.</li>
	     * </ul>
	     * <ul>
	     * <li>StringUtils.abbreviate(null, *) = null
	     * <li>StringUtils.abbreviate(&quot;&quot;, 4) = &quot;&quot;
	     * <li>StringUtils.abbreviate(&quot;abcdefg&quot;, 6) = &quot;abc...&quot;
	     * <li>StringUtils.abbreviate(&quot;abcdefg&quot;, 7) = &quot;abcdefg&quot;
	     * <li>StringUtils.abbreviate(&quot;abcdefg&quot;, 8) = &quot;abcdefg&quot;
	     * <li>StringUtils.abbreviate(&quot;abcdefg&quot;, 4) = &quot;a...&quot;
	     * <li>StringUtils.abbreviate(&quot;abcdefg&quot;, 3) =
	     * IllegalArgumentException
	     * </ul>
	     *
	     * @param str
	     *            체크할 문자열(NULL값이 될수도 있음)
	     * @param maxWidth
	     *            반환하는 문자열의 최대 길이이며 문자열을 최소한 4이상이어야한다.
	     * @return 축약된 문자열, 만일 NULL이 입력되면 <code>null</code>을 반환한다.
	     * @throws IllegalArgumentException
	     *             maxWidth가 4보자 작은경우 예외를 발생시킨다.
	     */
	    public static String abbreviate(String str, int maxWidth) {
	        return abbreviate(str, 0, maxWidth);
	    }

	    /**
	     * 생략 부호(...)와 함께 문자열을 줄여주는 메소드이다. "Now is the time for all good men"형태의
	     * 문자열을 "...is the time for..."형태로 되돌려준다.<br>
	     * 이메소드는 <code>abbreviate(String, int)</code>와 유사하게 작동하지만 문자열의 왼쪽의
	     * offset을 지정할수 있다.
	     * <ul>
	     * <li>StringUtils.abbreviate(null, *, *) = null
	     * <li>StringUtils.abbreviate(&quot;&quot;, 0, 4) = &quot;&quot;
	     * <li>StringUtils.abbreviate(&quot;abcdefghijklmno&quot;, -1, 10) =
	     * &quot;abcdefg...&quot;
	     * <li>StringUtils.abbreviate(&quot;abcdefghijklmno&quot;, 0, 10) =
	     * &quot;abcdefg...&quot;
	     * <li>StringUtils.abbreviate(&quot;abcdefghijklmno&quot;, 1, 10) =
	     * &quot;abcdefg...&quot;
	     * <li>StringUtils.abbreviate(&quot;abcdefghijklmno&quot;, 4, 10) =
	     * &quot;abcdefg...&quot;
	     * <li>StringUtils.abbreviate(&quot;abcdefghijklmno&quot;, 5, 10) =
	     * &quot;...fghi...&quot;
	     * <li>StringUtils.abbreviate(&quot;abcdefghijklmno&quot;, 6, 10) =
	     * &quot;...ghij...&quot;
	     * <li>StringUtils.abbreviate(&quot;abcdefghijklmno&quot;, 8, 10) =
	     * &quot;...ijklmno&quot;
	     * <li>StringUtils.abbreviate(&quot;abcdefghijklmno&quot;, 10, 10) =
	     * &quot;...ijklmno&quot;
	     * <li>StringUtils.abbreviate(&quot;abcdefghijklmno&quot;, 12, 10) =
	     * &quot;...ijklmno&quot;
	     * <li>StringUtils.abbreviate(&quot;abcdefghij&quot;, 0, 3) =
	     * IllegalArgumentException
	     * <li>StringUtils.abbreviate(&quot;abcdefghij&quot;, 5, 6) =
	     * IllegalArgumentException
	     * </ul>
	     *
	     * @param str
	     *            체크할 문자열(NULL값이 될수도 있음)
	     * @param offset
	     *            문자열의 왼쪽 Offse
	     * @param maxWidth
	     *            반환하는 문자열의 최대 길이이며 문자열을 최소한 4이상이어야한다.
	     * @return 축약된 문자열, 만일 NULL이 입력되면 <code>null</code>을 반환한다.
	     * @throws IllegalArgumentException
	     *             maxWidth가 4보자 작은경우 예외를 발생시킨다.
	     */
	    public static String abbreviate(String str, int offset, int maxWidth) {
	        if (str == null) {
	            return null;
	        }
	        if (maxWidth < 4) {
	            throw new IllegalArgumentException(
	                    "Minimum abbreviation width is 4");
	        }
	        if (str.length() <= maxWidth) {
	            return str;
	        }
	        if (offset > str.length()) {
	            offset = str.length();
	        }
	        if ((str.length() - offset) < (maxWidth - 3)) {
	            offset = str.length() - (maxWidth - 3);
	        }
	        if (offset <= 4) {
	            return str.substring(0, maxWidth - 3) + "...";
	        }
	        if (maxWidth < 7) {
	            throw new IllegalArgumentException(
	                    "Minimum abbreviation width with offset is 7");
	        }
	        if ((offset + (maxWidth - 3)) < str.length()) {
	            return "..." + abbreviate(str.substring(offset), maxWidth - 3);
	        }
	        return "..." + str.substring(str.length() - (maxWidth - 3));
	    }

	    // Case conversion
	    // -----------------------------------------------------------------------
	    /**
	     * 단어의 첫문자를 대문자로 변환하여준다.(입력 문자열이 null인경우 null을 반환한다.)<br>
	     * <ul>
	     * <li>StringUtils.capitalize(null) = null
	     * <li>StringUtils.capitalize(&quot;&quot;) = &quot;&quot;
	     * <li>StringUtils.capitalize(&quot;cat&quot;) = &quot;Cat&quot;
	     * <li>StringUtils.capitalize(&quot;cAt&quot;) = &quot;CAt&quot;
	     * </ul>
	     *
	     * @param str
	     *            첫 문자를 대문자로 변환하려는 문자열(입력 문자열이 null인경우 null을 반환한다.)
	     * @return
	     */
	    public static String capitalize(String str) {
	        int strLen;
	        if (str == null || (strLen = str.length()) == 0) {
	            return str;
	        }
	        return new StringBuffer(strLen).append(
	                Character.toTitleCase(str.charAt(0))).append(str.substring(1))
	                .toString();
	    }

	    /**
	     * 단어의 첫문자를 소문자로 변환하여준다.(입력 문자열이 null인경우 null을 반환한다.)<br>
	     * For a word based algorithm, see {@link WordUtils#uncapitalize(String)}.
	     * A <code>null</code> input String returns <code>null</code>.
	     * <ul>
	     * <li>StringUtils.uncapitalize(null) = null
	     * <li>StringUtils.uncapitalize(&quot;&quot;) = &quot;&quot;
	     * <li>StringUtils.uncapitalize(&quot;Cat&quot;) = &quot;cat&quot;
	     * <li>StringUtils.uncapitalize(&quot;CAT&quot;) = &quot;cAT&quot;
	     * </ul>
	     *
	     * @param str
	     *            첫 문자를 소문자로 변환하려는 문자열(입력 문자열이 null인경우 null을 반환한다.)
	     * @return
	     */
	    public static String uncapitalize(String str) {
	        int strLen;
	        if (str == null || (strLen = str.length()) == 0) {
	            return str;
	        }
	        return new StringBuffer(strLen).append(
	                Character.toLowerCase(str.charAt(0))).append(str.substring(1))
	                .toString();
	    }

	    // Centering
	    // -----------------------------------------------------------------------
	    /**
	     * 주어진 문자열(<code>str</code>)을 <code>size</code>변수 크기 안에서 중앙으로 배치하는
	     * 동시에 양 가장자리에는 빈 공백(' ')으로 채운다.<br>
	     * 만일 size가 주어진 문자열 길이보다 작은경우 그냥 문자열 자체를 반환한다. 문자열이 <code>null</code>인경우
	     * <code>null</code>을 반환한다. sieze값이 음수일경우 0으로 간주되어 처리된다.<br>
	     * Equivalent to <code>center(str, size, " ")</code>.
	     * <ul>
	     * <li>StringUtils.center(null, *) = null
	     * <li>StringUtils.center(&quot;&quot;, 4) = &quot; &quot;
	     * <li>StringUtils.center(&quot;ab&quot;, -1) = &quot;ab&quot;
	     * <li>StringUtils.center(&quot;ab&quot;, 4) = &quot; ab &quot;
	     * <li>StringUtils.center(&quot;abcd&quot;, 2) = &quot;abcd&quot;
	     * <li>StringUtils.center(&quot;a&quot;, 4) = &quot; a &quot;
	     * </ul>
	     *
	     * @param str
	     *            중앙에 위치시킬 문자열
	     * @param size
	     *            새로운 문자열의 크기, 음수는 0로 간주되어 처리된다.
	     * @return
	     */
	    public static String center(String str, int size) {
	        return center(str, size, ' ');
	    }

	    /**
	     * 주어진 문자열(<code>str</code>)을 <code>size</code>변수 크기 안에서 중앙으로 배치하는
	     * 동시에 양 가장자리에는 <code>padChar</code>문자로 채운다.<br>
	     * 만일 size가 주어진 문자열 길이보다 작은경우 그냥 문자열 자체를 반환한다. 문자열이 <code>null</code>인경우
	     * <code>null</code>을 반환한다. sieze값이 음수일경우 0으로 간주되어 처리된다.<br>
	     * <ul>
	     * <li>StringUtils.center(null, *, *) = null
	     * <li>StringUtils.center(&quot;&quot;, 4, ' ') = &quot; &quot;
	     * <li>StringUtils.center(&quot;ab&quot;, -1, ' ') = &quot;ab&quot;
	     * <li>StringUtils.center(&quot;ab&quot;, 4, ' ') = &quot; ab&quot;
	     * <li>StringUtils.center(&quot;abcd&quot;, 2, ' ') = &quot;abcd&quot;
	     * <li>StringUtils.center(&quot;a&quot;, 4, ' ') = &quot; a &quot;
	     * <li>StringUtils.center(&quot;a&quot;, 4, 'y') = &quot;yayy&quot;
	     * </ul>
	     *
	     * @param str
	     *            중앙에 위치시킬 문자열
	     * @param size
	     *            새로운 문자열의 크기, 음수는 0로 간주되어 처리된다.
	     * @param padChar
	     *            양쪽에 채워질 문자
	     * @return
	     */
	    public static String center(String str, int size, char padChar) {
	        if (str == null || size <= 0) {
	            return str;
	        }
	        int strLen = str.length();
	        int pads = size - strLen;
	        if (pads <= 0) {
	            return str;
	        }
	        str = leftPad(str, strLen + pads / 2, padChar);
	        str = rightPad(str, size, padChar);
	        return str;
	    }

	    /**
	     * 주어진 문자열(<code>str</code>)을 <code>size</code>변수 크기 안에서 중앙으로 배치하는
	     * 동시에 양 가장자리에는 <code>padStr</code>문자열로 채운다.<br>
	     * 만일 size가 주어진 문자열 길이보다 작은경우 그냥 문자열 자체를 반환한다. 문자열이 <code>null</code>인경우
	     * <code>null</code>을 반환한다. sieze값이 음수일경우 0으로 간주되어 처리된다.<br>
	     * <ul>
	     * <li>StringUtils.center(null, *, *) = null
	     * <li>StringUtils.center(&quot;&quot;, 4, &quot; &quot;) = &quot; &quot;
	     * <li>StringUtils.center(&quot;ab&quot;, -1, &quot; &quot;) =
	     * &quot;ab&quot;
	     * <li>StringUtils.center(&quot;ab&quot;, 4, &quot; &quot;) = &quot;
	     * ab&quot;
	     * <li>StringUtils.center(&quot;abcd&quot;, 2, &quot; &quot;) =
	     * &quot;abcd&quot;
	     * <li>StringUtils.center(&quot;a&quot;, 4, &quot; &quot;) = &quot; a
	     * &quot;
	     * <li>StringUtils.center(&quot;a&quot;, 4, &quot;yz&quot;) =
	     * &quot;yayz&quot;
	     * <li>StringUtils.center(&quot;abc&quot;, 7, null) = &quot; abc &quot;
	     * <li>StringUtils.center(&quot;abc&quot;, 7, &quot;&quot;) = &quot; abc
	     * &quot;
	     * </ul>
	     *
	     * @param str
	     *            중앙에 위치시킬 문자열
	     * @param size
	     *            새로운 문자열의 크기, 음수는 0로 간주되어 처리된다.
	     * @param padStr
	     *            양쪽에 채워질 문자열, 반드시 Null또는 빈문자열은 아니여야한다.
	     * @return centered
	     * @throws IllegalArgumentException
	     *             if padStr is <code>null</code> or empty
	     */
	    public static String center(String str, int size, String padStr) {
	        if (str == null || size <= 0) {
	            return str;
	        }
	        if (isEmpty(padStr)) {
	            padStr = " ";
	        }
	        int strLen = str.length();
	        int pads = size - strLen;
	        if (pads <= 0) {
	            return str;
	        }
	        str = leftPad(str, strLen + pads / 2, padStr);
	        str = rightPad(str, size, padStr);
	        return str;
	    }

	    // Splitting
	    // -----------------------------------------------------------------------
	    /**
	     * Performs the logic for the <code>split</code> and
	     * <code>splitPreserveAllTokens</code> methods that do not return a
	     * maximum array length.
	     *
	     * @param str
	     *            the String to parse, may be <code>null</code>
	     * @param separatorChar
	     *            the separate character
	     * @param preserveAllTokens
	     *            if <code>true</code>, adjacent separators are treated as
	     *            empty token separators; if <code>false</code>, adjacent
	     *            separators are treated as one separator.
	     * @return an array of parsed Strings, <code>null</code> if null String
	     *         input
	     */
	    private static String[] splitWorker(String str, char separatorChar,
	            boolean preserveAllTokens) {
	        // Performance tuned for 2.0 (JDK1.4)

	        if (str == null) {
	            return null;
	        }
	        int len = str.length();
	        if (len == 0) {
	            return EMPTY_STRING_ARRAY;
	        }
	        List list = new ArrayList();
	        int i = 0, start = 0;
	        boolean match = false;
	        boolean lastMatch = false;
	        while (i < len) {
	            if (str.charAt(i) == separatorChar) {
	                if (match || preserveAllTokens) {
	                    list.add(str.substring(start, i));
	                    match = false;
	                    lastMatch = true;
	                }
	                start = ++i;
	                continue;
	            } else {
	                lastMatch = false;
	            }
	            match = true;
	            i++;
	        }
	        if (match || (preserveAllTokens && lastMatch)) {
	            list.add(str.substring(start, i));
	        }
	        return (String[]) list.toArray(new String[list.size()]);
	    }

	    /**
	     * Performs the logic for the <code>split</code> and
	     * <code>splitPreserveAllTokens</code> methods that return a maximum array
	     * length.
	     *
	     * @param str
	     *            the String to parse, may be <code>null</code>
	     * @param separatorChars
	     *            the separate character
	     * @param max
	     *            the maximum number of elements to include in the array. A zero
	     *            or negative value implies no limit.
	     * @param preserveAllTokens
	     *            if <code>true</code>, adjacent separators are treated as
	     *            empty token separators; if <code>false</code>, adjacent
	     *            separators are treated as one separator.
	     * @return an array of parsed Strings, <code>null</code> if null String
	     *         input
	     */
	    private static String[] splitWorker(String str, String separatorChars,
	            int max, boolean preserveAllTokens) {
	        // Performance tuned for 2.0 (JDK1.4)
	        // Direct code is quicker than StringTokenizer.
	        // Also, StringTokenizer uses isSpace() not isWhitespace()

	        if (str == null) {
	            return null;
	        }
	        int len = str.length();
	        if (len == 0) {
	            return EMPTY_STRING_ARRAY;
	        }
	        List list = new ArrayList();
	        int sizePlus1 = 1;
	        int i = 0, start = 0;
	        boolean match = false;
	        boolean lastMatch = false;
	        if (separatorChars == null) {
	            // Null separator means use whitespace
	            while (i < len) {
	                if (Character.isWhitespace(str.charAt(i))) {
	                    if (match || preserveAllTokens) {
	                        lastMatch = true;
	                        if (sizePlus1++ == max) {
	                            i = len;
	                            lastMatch = false;
	                        }
	                        list.add(str.substring(start, i));
	                        match = false;
	                    }
	                    start = ++i;
	                    continue;
	                } else {
	                    lastMatch = false;
	                }
	                match = true;
	                i++;
	            }
	        } else if (separatorChars.length() == 1) {
	            // Optimise 1 character case
	            char sep = separatorChars.charAt(0);
	            while (i < len) {
	                if (str.charAt(i) == sep) {
	                    if (match || preserveAllTokens) {
	                        lastMatch = true;
	                        if (sizePlus1++ == max) {
	                            i = len;
	                            lastMatch = false;
	                        }
	                        list.add(str.substring(start, i));
	                        match = false;
	                    }
	                    start = ++i;
	                    continue;
	                } else {
	                    lastMatch = false;
	                }
	                match = true;
	                i++;
	            }
	        } else {
	            // standard case
	            while (i < len) {
	                if (separatorChars.indexOf(str.charAt(i)) >= 0) {
	                    if (match || preserveAllTokens) {
	                        lastMatch = true;
	                        if (sizePlus1++ == max) {
	                            i = len;
	                            lastMatch = false;
	                        }
	                        list.add(str.substring(start, i));
	                        match = false;
	                    }
	                    start = ++i;
	                    continue;
	                } else {
	                    lastMatch = false;
	                }
	                match = true;
	                i++;
	            }
	        }
	        if (match || (preserveAllTokens && lastMatch)) {
	            list.add(str.substring(start, i));
	        }
	        return (String[]) list.toArray(new String[list.size()]);
	    }

	    // Padding
	    // -----------------------------------------------------------------------
	    /**
	     * 두번째 매개변수 만큼 첫번째 매개변수 문자열을 반복하여 채운 다음 반환한다.
	     * <ul>
	     * <li>StringUtils.repeat(null, 2) = null
	     * <li>StringUtils.repeat(&quot;&quot;, 0) = &quot;&quot;
	     * <li>StringUtils.repeat(&quot;&quot;, 2) = &quot;&quot;
	     * <li>StringUtils.repeat(&quot;a&quot;, 3) = &quot;aaa&quot;
	     * <li>StringUtils.repeat(&quot;ab&quot;, 2) = &quot;abab&quot;
	     * <li>StringUtils.repeat(&quot;a&quot;, -2) = &quot;&quot;
	     * </ul>
	     *
	     * @param str
	     *            반복할 문자열
	     * @param repeat
	     *            반복할 횟수, 음수는 0으로 취급되어 처리된다.
	     * @return
	     */
	    public static String repeat(String str, int repeat) {
	        // Performance tuned for 2.0 (JDK1.4)

	        if (str == null) {
	            return null;
	        }
	        if (repeat <= 0) {
	            return EMPTY;
	        }
	        int inputLength = str.length();
	        if (repeat == 1 || inputLength == 0) {
	            return str;
	        }
	        if (inputLength == 1 && repeat <= PAD_LIMIT) {
	            return padding(repeat, str.charAt(0));
	        }

	        int outputLength = inputLength * repeat;
	        switch (inputLength) {
	        case 1:
	            char ch = str.charAt(0);
	            char[] output1 = new char[outputLength];
	            for (int i = repeat - 1; i >= 0; i--) {
	                output1[i] = ch;
	            }
	            return new String(output1);
	        case 2:
	            char ch0 = str.charAt(0);
	            char ch1 = str.charAt(1);
	            char[] output2 = new char[outputLength];
	            for (int i = repeat * 2 - 2; i >= 0; i--, i--) {
	                output2[i] = ch0;
	                output2[i + 1] = ch1;
	            }
	            return new String(output2);
	        default:
	            StringBuffer buf = new StringBuffer(outputLength);
	            for (int i = 0; i < repeat; i++) {
	                buf.append(str);
	            }
	            return buf.toString();
	        }
	    }

	    /**
	     * 첫번째 매개변수 만큼 두번째 매개변수 문자를 반복하여 채운 다음 반환한다.
	     * <ul>
	     * <li>StringUtils.padding(0, 'e') = &quot;&quot;
	     * <li>StringUtils.padding(3, 'e') = &quot;eee&quot;
	     * <li>StringUtils.padding(-2, 'e') = IndexOutOfBoundsException
	     * </ul>
	     *
	     * @param repeat
	     *            반복할 횟수
	     * @param padChar
	     *            반복할 문자.
	     * @return
	     * @throws IndexOutOfBoundsException
	     *             if <code>repeat &lt; 0</code>
	     */
	    private static String padding(int repeat, char padChar) {
	        // be careful of synchronization in this method
	        // we are assuming that get and set from an array index is atomic
	        String pad = PADDING[padChar];
	        if (pad == null) {
	            pad = String.valueOf(padChar);
	        }
	        while (pad.length() < repeat) {
	            pad = pad.concat(pad);
	        }
	        PADDING[padChar] = pad;
	        return pad.substring(0, repeat);
	    }

	    /**
	     * 주어진 문자열(<code>str</code>)이
	     * <code>size<code>보다 작은경우 남는 자리만큼 문자열의 왼쪽에 ''문자를 채워 넎는다.
	     *
	     * <ul>
	     *   <li>StringUtils.leftPad(null, *)   = null
	     *   <li>StringUtils.leftPad(&quot;&quot;, 3)     = &quot;   &quot;
	     *   <li>StringUtils.leftPad(&quot;bat&quot;, 3)  = &quot;bat&quot;
	     *   <li>StringUtils.leftPad(&quot;bat&quot;, 5)  = &quot;  bat&quot;
	     *   <li>StringUtils.leftPad(&quot;bat&quot;, 1)  = &quot;bat&quot;
	     *   <li>StringUtils.leftPad(&quot;bat&quot;, -1) = &quot;bat&quot;
	     * </ul>
	     *
	     * @param str  Pad out될 문자열
	     * @param size  Pad out되어 처리될 전체길이 문자열 크기
	     * @return
	     */
	    public static String leftPad(String str, int size) {
	        return leftPad(str, size, ' ');
	    }

	    /**
	     * 주어진 문자열(<code>str</code>)이
	     * <code>size<code>보다 작은경우 남는 자리만큼 문자열의 왼쪽에<code>padChar</code>문자를 채워 넎는다.
	     *
	     * <ul>
	     *   <li>StringUtils.leftPad(null, *, *)     = null
	     *   <li>StringUtils.leftPad(&quot;&quot;, 3, 'z')     = &quot;zzz&quot;
	     *   <li>StringUtils.leftPad(&quot;bat&quot;, 3, 'z')  = &quot;bat&quot;
	     *   <li>StringUtils.leftPad(&quot;bat&quot;, 5, 'z')  = &quot;zzbat&quot;
	     *   <li>StringUtils.leftPad(&quot;bat&quot;, 1, 'z')  = &quot;bat&quot;
	     *   <li>StringUtils.leftPad(&quot;bat&quot;, -1, 'z') = &quot;bat&quot;
	     * </ul>
	     *
	     * @param str Pad out될 문자열
	     * @param size Pad out되어 처리될 전체길이 문자열 크기
	     * @param padChar 채워질 특정 문자
	     * @return
	     */
	    public static String leftPad(String str, int size, char padChar) {
	        if (str == null) {
	            return null;
	        }
	        int pads = size - str.length();
	        if (pads <= 0) {
	            return str; // returns original String when possible
	        }
	        if (pads > PAD_LIMIT) {
	            return leftPad(str, size, String.valueOf(padChar));
	        }
	        return padding(pads, padChar).concat(str);
	    }

	    /**
	     * 주어진 문자열(<code>str</code>)이
	     * <code>size<code>보다 작은경우 남는 자리만큼 문자열의 왼쪽에<code>padStr</code>문자열을 채워 넎는다.
	     *
	     * <ul>
	     *   <li>StringUtils.leftPad(null, *, *)      = null
	     *   <li>StringUtils.leftPad(&quot;&quot;, 3, &quot;z&quot;)      = &quot;zzz&quot;
	     *   <li>StringUtils.leftPad(&quot;bat&quot;, 3, &quot;yz&quot;)  = &quot;bat&quot;
	     *   <li>StringUtils.leftPad(&quot;bat&quot;, 5, &quot;yz&quot;)  = &quot;yzbat&quot;
	     *   <li>StringUtils.leftPad(&quot;bat&quot;, 8, &quot;yz&quot;)  = &quot;yzyzybat&quot;
	     *   <li>StringUtils.leftPad(&quot;bat&quot;, 1, &quot;yz&quot;)  = &quot;bat&quot;
	     *   <li>StringUtils.leftPad(&quot;bat&quot;, -1, &quot;yz&quot;) = &quot;bat&quot;
	     *   <li>StringUtils.leftPad(&quot;bat&quot;, 5, null)  = &quot;  bat&quot;
	     *   <li>StringUtils.leftPad(&quot;bat&quot;, 5, &quot;&quot;)    = &quot;  bat&quot;
	     * </ul>
	     *
	     * @param str Pad out될 문자열
	     * @param size Pad out되어 처리될 전체길이 문자열 크기
	     * @param padStr 채워질 특정 문자열, null 또는 빈 문자열은 하나의 빈 문자(' ')로 취급되어 처리된다.
	     * @return
	     */
	    public static String leftPad(String str, int size, String padStr) {
	        if (str == null) {
	            return null;
	        }
	        if (isEmpty(padStr)) {
	            padStr = " ";
	        }
	        int padLen = padStr.length();
	        int strLen = str.length();
	        int pads = size - strLen;
	        if (pads <= 0) {
	            return str; // returns original String when possible
	        }
	        if (padLen == 1 && pads <= PAD_LIMIT) {
	            return leftPad(str, size, padStr.charAt(0));
	        }

	        if (pads == padLen) {
	            return padStr.concat(str);
	        } else if (pads < padLen) {
	            return padStr.substring(0, pads).concat(str);
	        } else {
	            char[] padding = new char[pads];
	            char[] padChars = padStr.toCharArray();
	            for (int i = 0; i < pads; i++) {
	                padding[i] = padChars[i % padLen];
	            }
	            return new String(padding).concat(str);
	        }
	    }

	    /**
	     * 주어진 문자열(<code>str</code>)이
	     * <code>size<code>보다 작은경우 남는 자리만큼 문자열의 오른쪽에 ''문자를 채워 넎는다.
	     *
	     * <ul>
	     *   <li>StringUtils.rightPad(null, *)   = null
	     *   <li>StringUtils.rightPad(&quot;&quot;, 3)     = &quot;   &quot;
	     *   <li>StringUtils.rightPad(&quot;bat&quot;, 3)  = &quot;bat&quot;
	     *   <li>StringUtils.rightPad(&quot;bat&quot;, 5)  = &quot;bat  &quot;
	     *   <li>StringUtils.rightPad(&quot;bat&quot;, 1)  = &quot;bat&quot;
	     *   <li>StringUtils.rightPad(&quot;bat&quot;, -1) = &quot;bat&quot;
	     * </ul>
	     *
	     * @param str  Pad out될 문자열
	     * @param size  Pad out되어 처리될 전체길이 문자열 크기
	     * @return
	     */
	    public static String rightPad(String str, int size) {
	        return rightPad(str, size, ' ');
	    }

	    /**
	     * 주어진 문자열(<code>str</code>)이
	     * <code>size<code>보다 작은경우 남는 자리만큼 문자열의 오른쪽에<code>padChar</code>문자를 채워 넎는다.
	     *
	     * <ul>
	     *   <li>StringUtils.rightPad(null, *, *)     = null
	     *   <li>StringUtils.rightPad(&quot;&quot;, 3, 'z')     = &quot;zzz&quot;
	     *   <li>StringUtils.rightPad(&quot;bat&quot;, 3, 'z')  = &quot;bat&quot;
	     *   <li>StringUtils.rightPad(&quot;bat&quot;, 5, 'z')  = &quot;batzz&quot;
	     *   <li>StringUtils.rightPad(&quot;bat&quot;, 1, 'z')  = &quot;bat&quot;
	     *   <li>StringUtils.rightPad(&quot;bat&quot;, -1, 'z') = &quot;bat&quot;
	     * </ul>
	     *
	     * @param str Pad out될 문자열
	     * @param size Pad out되어 처리될 전체길이 문자열 크기
	     * @param padChar 채워질 특정 문자
	     * @return
	     */
	    public static String rightPad(String str, int size, char padChar) {
	        if (str == null) {
	            return null;
	        }
	        int pads = size - str.length();
	        if (pads <= 0) {
	            return str; // returns original String when possible
	        }
	        if (pads > PAD_LIMIT) {
	            return rightPad(str, size, String.valueOf(padChar));
	        }
	        return str.concat(padding(pads, padChar));
	    }

	    /**
	     * 주어진 문자열(<code>str</code>)이
	     * <code>size<code>보다 작은경우 남는 자리만큼 문자열의 오른쪽에<code>padStr</code>문자열을 채워 넎는다.
	     *
	     * <ul>
	     *   <li>StringUtils.rightPad(null, *, *)      = null
	     *   <li>StringUtils.rightPad(&quot;&quot;, 3, &quot;z&quot;)      = &quot;zzz&quot;
	     *   <li>StringUtils.rightPad(&quot;bat&quot;, 3, &quot;yz&quot;)  = &quot;bat&quot;
	     *   <li>StringUtils.rightPad(&quot;bat&quot;, 5, &quot;yz&quot;)  = &quot;batyz&quot;
	     *   <li>StringUtils.rightPad(&quot;bat&quot;, 8, &quot;yz&quot;)  = &quot;batyzyzy&quot;
	     *   <li>StringUtils.rightPad(&quot;bat&quot;, 1, &quot;yz&quot;)  = &quot;bat&quot;
	     *   <li>StringUtils.rightPad(&quot;bat&quot;, -1, &quot;yz&quot;) = &quot;bat&quot;
	     *   <li>StringUtils.rightPad(&quot;bat&quot;, 5, null)  = &quot;bat  &quot;
	     *   <li>StringUtils.rightPad(&quot;bat&quot;, 5, &quot;&quot;)    = &quot;bat  &quot;
	     * </ul>
	     *
	     * @param str Pad out될 문자열
	     * @param size Pad out되어 처리될 전체길이 문자열 크기
	     * @param padStr 채워질 특정 문자열, null 또는 빈 문자열은 하나의 빈 문자(' ')로 취급되어 처리된다.
	     * @return
	     */
	    public static String rightPad(String str, int size, String padStr) {
	        if (str == null) {
	            return null;
	        }
	        if (isEmpty(padStr)) {
	            padStr = " ";
	        }
	        int padLen = padStr.length();
	        int strLen = str.length();
	        int pads = size - strLen;
	        if (pads <= 0) {
	            return str; // returns original String when possible
	        }
	        if (padLen == 1 && pads <= PAD_LIMIT) {
	            return rightPad(str, size, padStr.charAt(0));
	        }

	        if (pads == padLen) {
	            return str.concat(padStr);
	        } else if (pads < padLen) {
	            return str.concat(padStr.substring(0, pads));
	        } else {
	            char[] padding = new char[pads];
	            char[] padChars = padStr.toCharArray();
	            for (int i = 0; i < pads; i++) {
	                padding[i] = padChars[i % padLen];
	            }
	            return str.concat(new String(padding));
	        }
	    }

	    /**
	     * 입력받은 부동소숫점 숫자를(String형) 지정된 자리수만큼 반올림하여 반환한다.<br>
	     *
	     * @param floatValue
	     *            소숫점이 있는 숫자
	     * @param precision
	     *            표현할 소숫점 자리수
	     * @return
	     */
	    public static String round(String floatValue, int precision) {
	        String returnValue = null;
	        StringBuffer pattern = new StringBuffer("0");
	        double dubleValue = 0.0;

	        if (isNotEmpty(floatValue)) {
	            dubleValue = Double.parseDouble(floatValue);
	            if (precision > 0) {
	                pattern.append(".");
	                for (int i = 0; i < precision; i++) {
	                    pattern.append("#");
	                }
	            }
	            DecimalFormat df = new DecimalFormat(pattern.toString());
	            returnValue = df.format(dubleValue);
	        }

	        return returnValue;
	    }

	    // Splitting
	    // -----------------------------------------------------------------------
	    /**
	     * 주어진 문자열을 빈 공백문자를 구분자로 사용하여 배열로서 반환한다. Whitespace is defined by
	     * {@link Character#isWhitespace(char)}.<br>
	     * 참조클래스 : StrTokenizer class.<br>
	     * <code>null</code>값으로 입력된 문자열은 <code>null</code>을 리턴한다.
	     * <ul>
	     * <li>StringUtils.split(null) = null
	     * <li>StringUtils.split(&quot;&quot;) = []
	     * <li>StringUtils.split(&quot;abc def&quot;) = [&quot;abc&quot;,
	     * &quot;def&quot;]
	     * <li>StringUtils.split(&quot;abc def&quot;) = [&quot;abc&quot;,
	     * &quot;def&quot;]
	     * <li>StringUtils.split(&quot; abc &quot;) = [&quot;abc&quot;]
	     * </ul>
	     *
	     * @param str
	     *            배열로 변환될 문자열
	     * @return
	     */
	    public static String[] split(String str) {
	        return split(str, null, -1);
	    }

	    /**
	     * 주어진 문자열을 지정된 문자(<code>separatorChar</code>)에의한 구분자로 배열로서 반환한다.
	     * StrTokenizer와 병행하여 사용가능하다.<br>
	     * 참조클래스 : StrTokenizer class.<br>
	     * <code>null</code>값으로 입력된 문자열은 <code>null</code>을 리턴한다.
	     * <ul>
	     * <li>StringUtils.split(null, *) = null
	     * <li>StringUtils.split(&quot;&quot;, *) = []
	     * <li>StringUtils.split(&quot;a.b.c&quot;, '.') = [&quot;a&quot;,
	     * &quot;b&quot;, &quot;c&quot;]
	     * <li>StringUtils.split(&quot;a..b.c&quot;, '.') = [&quot;a&quot;,
	     * &quot;b&quot;, &quot;c&quot;]
	     * <li>StringUtils.split(&quot;a:b:c&quot;, '.') = [&quot;a:b:c&quot;]
	     * <li>StringUtils.split(&quot;a\tb\nc&quot;, null) = [&quot;a&quot;,
	     * &quot;b&quot;, &quot;c&quot;]
	     * <li>StringUtils.split(&quot;a b c&quot;, ' ') = [&quot;a&quot;,
	     * &quot;b&quot;, &quot;c&quot;]
	     * </ul>
	     *
	     * @param str
	     *            배열로 변환될 문자열
	     * @param separatorChar
	     *            구분자로 사용될 딜리미터(delimiter), <code>null</code>값은 빈공백 문자로 간주되어
	     *            처리된다.
	     * @return
	     */
	    public static String[] split(String str, char separatorChar) {
	        return splitWorker(str, separatorChar, false);
	    }

	    /**
	     * 주어진 문자열을 <code>maximum</code>길이만큼의 배열로 되돌려주며 구분자가 제공되어진다.<br>
	     * <code>maximum</code>가 0이거나 음수인경우 배열의 크기는 제한이 없는것으로 간주되어진다.
	     * <ul>
	     * <li>StringUtils.split(null, *, *) = null
	     * <li>StringUtils.split(&quot;&quot;, *, *) = []
	     * <li>StringUtils.split(&quot;ab de fg&quot;, null, 0) = [&quot;ab&quot;,
	     * &quot;cd&quot;, &quot;ef&quot;]
	     * <li>StringUtils.split(&quot;ab de fg&quot;, null, 0) = [&quot;ab&quot;,
	     * &quot;cd&quot;, &quot;ef&quot;]
	     * <li>StringUtils.split(&quot;ab:cd:ef&quot;, &quot;:&quot;, 0) =
	     * [&quot;ab&quot;, &quot;cd&quot;, &quot;ef&quot;]
	     * <li>StringUtils.split(&quot;ab:cd:ef&quot;, &quot;:&quot;, 2) =
	     * [&quot;ab&quot;, &quot;cd:ef&quot;]
	     * </ul>
	     *
	     * @param str
	     *            배열로 변환될 문자열
	     * @param separatorChars
	     *            구분자로 사용될 딜리미터(delimiter) 문자열, <code>null</code>값은 빈공백 문자로
	     *            간주되어 처리된다.
	     * @param max
	     *            <code>maximum</code>가 0이거나 음수인경우 배열의 크기는 제한이 없는것으로 간주되어진다.
	     * @return
	     */
	    public static String[] split(String str, String separatorChars, int max) {
	        return splitWorker(str, separatorChars, max, false);
	    }

	    /**
	     * Splits the provided text into an array, separator string specified.<br>
	     * The separator(s) will not be included in the returned String array.
	     * Adjacent separators are treated as one separator.<br>
	     * A <code>null</code> input String returns <code>null</code>. A
	     * <code>null</code> separator splits on whitespace.
	     * <ul>
	     * <li>StringUtils.split(null, *) = null
	     * <li>StringUtils.split("", *) = []
	     * <li>StringUtils.split("ab de fg", null) = ["ab", "de", "fg"]
	     * <li>StringUtils.split("ab de fg", null) = ["ab", "de", "fg"]
	     * <li>StringUtils.split("ab:cd:ef", ":") = ["ab", "cd", "ef"]
	     * <li>StringUtils.split("abstemiouslyaeiouyabstemiously", "aeiouy") =
	     * ["bst", "m", "sl", "bst", "m", "sl"]
	     * <li>StringUtils.split("abstemiouslyaeiouyabstemiously", "aeiouy") =
	     * ["abstemiously", "abstemiously"]
	     * </ul>
	     *
	     * @param str
	     *            the String to parse, may be null
	     * @param separator
	     *            String containing the String to be used as a delimiter,
	     *            <code>null</code> splits on whitespace
	     * @return an array of parsed Strings, <code>null</code> if null String
	     *         was input
	     */
	    public static String[] splitByWholeSeparator(String str, String separator) {
	        return splitByWholeSeparator(str, separator, -1);
	    }

	    /**
	     * Splits the provided text into an array, separator string specified.
	     * Returns a maximum of <code>max</code> substrings.<br>
	     * The separator(s) will not be included in the returned String array.
	     * Adjacent separators are treated as one separator.<br>
	     * A <code>null</code> input String returns <code>null</code>. A
	     * <code>null</code> separator splits on whitespace.
	     * <ul>
	     * <li>StringUtils.splitByWholeSeparator(null, *, *) = null
	     * <li>StringUtils.splitByWholeSeparator("", *, *) = []
	     * <li>StringUtils.splitByWholeSeparator("ab de fg", null, 0) = ["ab",
	     * "de", "fg"]
	     * <li>StringUtils.splitByWholeSeparator("ab de fg", null, 0) = ["ab",
	     * "de", "fg"]
	     * <li>StringUtils.splitByWholeSeparator("ab:cd:ef", ":", 2) = ["ab", "cd"]
	     * <li>StringUtils.splitByWholeSeparator("abstemiouslyaeiouyabstemiously",
	     * "aeiouy", 2) = ["bst", "m"]
	     * <li>StringUtils.splitByWholeSeparator("abstemiouslyaeiouyabstemiously",
	     * "aeiouy", 2) = ["abstemiously", "abstemiously"]
	     * </ul>
	     *
	     * @param str
	     *            the String to parse, may be null
	     * @param separator
	     *            String containing the String to be used as a delimiter,
	     *            <code>null</code> splits on whitespace
	     * @param max
	     *            the maximum number of elements to include in the returned
	     *            array. A zero or negative value implies no limit.
	     * @return an array of parsed Strings, <code>null</code> if null String
	     *         was input
	     */
	    public static String[] splitByWholeSeparator(String str, String separator,
	            int max) {
	        if (str == null) {
	            return null;
	        }

	        int len = str.length();

	        if (len == 0) {
	            return EMPTY_STRING_ARRAY;
	        }

	        if ((separator == null) || ("".equals(separator))) {
	            // Split on whitespace.
	            return split(str, null, max);
	        }

	        int separatorLength = separator.length();

	        ArrayList substrings = new ArrayList();
	        int numberOfSubstrings = 0;
	        int beg = 0;
	        int end = 0;
	        while (end < len) {
	            end = str.indexOf(separator, beg);

	            if (end > -1) {
	                if (end > beg) {
	                    numberOfSubstrings += 1;

	                    if (numberOfSubstrings == max) {
	                        end = len;
	                        substrings.add(str.substring(beg));
	                    } else {
	                        // The following is OK, because String.substring( beg,
	                        // end ) excludes
	                        // the character at the position 'end'.
	                        substrings.add(str.substring(beg, end));

	                        // Set the starting point for the next search.
	                        // The following is equivalent to beg = end +
	                        // (separatorLength - 1) + 1,
	                        // which is the right calculation:
	                        beg = end + separatorLength;
	                    }
	                } else {
	                    // We found a consecutive occurrence of the separator, so
	                    // skip it.
	                    beg = end + separatorLength;
	                }
	            } else {
	                // String.substring( beg ) goes from 'beg' to the end of the
	                // String.
	                substrings.add(str.substring(beg));
	                end = len;
	            }
	        }

	        return (String[]) substrings.toArray(new String[substrings.size()]);
	    }

	    /**
	     * Splits the provided text into an array, using whitespace as the
	     * separator, preserving all tokens, including empty tokens created by
	     * adjacent separators. This is an alternative to using StringTokenizer.
	     * Whitespace is defined by<br>
	     * {@link Character#isWhitespace(char)}.<br>
	     * The separator is not included in the returned String array. Adjacent
	     * separators are treated as separators for empty tokens. For more control
	     * over the split use the StrTokenizer class.<br>
	     * A <code>null</code> input String returns <code>null</code>.
	     * </p>
	     * <ul>
	     * <li>StringUtils.splitPreserveAllTokens(null) = null
	     * <li>StringUtils.splitPreserveAllTokens("") = []
	     * <li>StringUtils.splitPreserveAllTokens("abc def") = ["abc", "def"]
	     * <li>StringUtils.splitPreserveAllTokens("abc def") = ["abc", "", "def"]
	     * <li>StringUtils.splitPreserveAllTokens(" abc ") = ["", "abc", ""]
	     * </ul>
	     *
	     * @param str
	     *            the String to parse, may be <code>null</code>
	     * @return an array of parsed Strings, <code>null</code> if null String
	     *         input
	     */
	    public static String[] splitPreserveAllTokens(String str) {
	        return splitWorker(str, null, -1, true);
	    }

	    /**
	     * Splits the provided text into an array, separator specified, preserving
	     * all tokens, including empty tokens created by adjacent separators. This
	     * is an alternative to using StringTokenizer.<br>
	     * The separator is not included in the returned String array. Adjacent
	     * separators are treated as separators for empty tokens. For more control
	     * over the split use the StrTokenizer class.<br>
	     * A <code>null</code> input String returns <code>null</code>.
	     * <ul>
	     * <li>StringUtils.splitPreserveAllTokens(null, *) = null
	     * <li>StringUtils.splitPreserveAllTokens("", *) = []
	     * <li>StringUtils.splitPreserveAllTokens("a.b.c", '.') = ["a", "b", "c"]
	     * <li>StringUtils.splitPreserveAllTokens("a..b.c", '.') = ["a", "b", "c"]
	     * <li>StringUtils.splitPreserveAllTokens("a:b:c", '.') = ["a:b:c"]
	     * <li>StringUtils.splitPreserveAllTokens("a\tb\nc", null) = ["a", "b",
	     * "c"]
	     * <li>StringUtils.splitPreserveAllTokens("a b c", ' ') = ["a", "b", "c"]
	     * <li>StringUtils.splitPreserveAllTokens("a b c ", ' ') = ["a", "b", "c",
	     * ""]
	     * <li>StringUtils.splitPreserveAllTokens("a b c ", ' ') = ["a", "b", "c",
	     * "", ""]
	     * <li>StringUtils.splitPreserveAllTokens(" a b c", ' ') = ["", a", "b",
	     * "c"]
	     * <li>StringUtils.splitPreserveAllTokens(" a b c", ' ') = ["", "", a",
	     * "b", "c"]
	     * <li>StringUtils.splitPreserveAllTokens(" a b c ", ' ') = ["", a", "b",
	     * "c", ""]
	     * </ul>
	     *
	     * @param str
	     *            the String to parse, may be <code>null</code>
	     * @param separatorChar
	     *            the character used as the delimiter, <code>null</code>
	     *            splits on whitespace
	     * @return an array of parsed Strings, <code>null</code> if null String
	     *         input
	     */
	    public static String[] splitPreserveAllTokens(String str, char separatorChar) {
	        return splitWorker(str, separatorChar, true);
	    }

	    /**
	     * str.getBytes("Cp1252"), "EUC_KR")
	     *
	     * @param str
	     * @return
	     */
	    public static String convertCp125ToEuckr(String str) {
	        try {
	            if (str != null)
	                return new String(str.getBytes("Cp1252"), "EUC_KR").trim();
	            else
	                return null;
	        } catch (Exception e) {
	            e.printStackTrace();
	            return null;
	        }
	    }

	    /**
	     * str.getBytes("8859_1"), "ksc5601")
	     *
	     * @param str
	     * @return
	     */
	    public static String convert88591_1ToKSC5601(String str) {
	        try {
	            if (str != null)
	                return new String(str.getBytes("8859_1"), "ksc5601").trim();
	            else
	                return null;
	        } catch (Exception e) {
	            e.printStackTrace();
	            return null;
	        }
	    }

	    /**
	     * str.getBytes("8859_1"), "ksc5601")
	     *
	     * @param str
	     * @return
	     */
	    public static String convertKSC5601To88591_1(String str) {
	        try {
	            if (str != null)
	                return new String(str.getBytes("ksc5601"), "8859_1").trim();
	            else
	                return null;
	        } catch (Exception e) {
	            e.printStackTrace();
	            return null;
	        }
	    }

	    /**
	     * @param str
	     * @return
	     */
	    public static String convertEucKrToUTF8(String str) {
	        try {
	            if (str != null)
	                return new String(str.getBytes("EUC_KR"), "UTF-8").trim();
	            else
	                return null;
	        } catch (Exception e) {
	            e.printStackTrace();
	            return null;
	        }
	    }

	    /**
	     * @param str
	     * @return
	     */
	    public static String convert8859_1ToEucKr(String str) {
	        try {
	            if (str != null)
	                return new String(str.getBytes("8859_1"), "EUC_KR").trim();
	            else
	                return null;
	        } catch (Exception e) {
	            e.printStackTrace();
	            return null;
	        }
	    }

	    /**
	     * @param str
	     * @return
	     */
	    public static String convertEUC_KRTo8859_1(String str) {
	        try {
	            if (str != null)
	                return new String(str.getBytes("EUC_KR"), "8859_1").trim();
	            else
	                return null;
	        } catch (Exception e) {
	            e.printStackTrace();
	            return null;
	        }
	    }

	    /**
	     * @param str
	     * @return
	     */
	    public static String convert8859_1ToMS949(String str) {
	        try {
	            if (str != null)
	                return new String(str.getBytes("8859_1"), "MS949").trim();
	            else
	                return null;
	        } catch (Exception e) {
	            e.printStackTrace();
	            return null;
	        }
	    }

	    /**
	     * @param str
	     * @return
	     */
	    public static String convertEucKrToISO8859_1(String str) {
	        try {
	            if (str != null)
	                return new String(str.getBytes("EUC_KR"), "ISO8859_1").trim();
	            else
	                return null;
	        } catch (Exception e) {
	            e.printStackTrace();
	            return null;
	        }
	    }

	    /**
	     * Essbase에서 입력되지 않는 문자, 즉 Double값을 특정 한 값으로 변환해주는 메소드이다.<br>
	     * 입력 매개변수를 Essbase에서 처리하는 Double값인지를 검사해서 Null값이면 특정문자로 반환한다.
	     *
	     * @param doubleValue
	     * @return
	     * @throws Exception
	     */
	    public static String null2Char(double doubleValue) throws Exception {

	        // DecimalFormat formatter = new DecimalFormat("#,##0.0");

	        if (doubleValue == 1.7976931348623157E+308D) {
	            return "-";

	        } else {
	            return null2Char(doubleValue, "0", 0);
	        }

	    }

	    /**
	     * Essbase에서 입력되지 않는 문자, 즉 Double값을 특정 한 값으로 변환해주는 메소드이다.<br>
	     * 입력 매개변수를 Essbase에서 처리하는 Double값인지를 검사해서 Null값이면 특정문자로 반환한다.
	     *
	     * @param doubleValue
	     * @param defaultValue
	     * @return
	     * @throws Exception
	     */
	    public static String null2Char(double doubleValue, String defaultValue)
	            throws Exception {
	        // DecimalFormat formatter = new DecimalFormat("#,###");
	        if (doubleValue == 1.7976931348623157E+308D) {
	            return defaultValue;
	        } else {
	            // roundUp(doubleValue, 1)
	            return null2Char(doubleValue, "0", 0);
	        }

	    }

	    /**
	     * Essbase에서 입력되지 않는 문자, 즉 Double값을 특정 한 값으로 변환해주는 메소드이다.<br>
	     * 입력 매개변수를 Essbase에서 처리하는 Double값인지를 검사해서 Null값이면 특정문자로 반환한다.<br>
	     * decimalPre값의 소수점 이하 반올림 처리
	     *
	     * @param doubleValue
	     * @param defaultValue
	     * @param decimalPre
	     * @return
	     * @throws Exception
	     */
	    public static String null2Char(double doubleValue, String defaultValue,
	            int decimalPre) throws Exception {

	        DecimalFormat myFormatter = new DecimalFormat("#,##0.0000000000");
	        if (decimalPre == 0)
	            decimalPre--;
	        if (doubleValue == 1.7976931348623157E+308D) {
	            return defaultValue;

	        } else {
	            doubleValue = roundUp(doubleValue, decimalPre);
	            return myFormatter.format(doubleValue).substring(
	                    0,
	                    myFormatter.format(doubleValue).length()
	                            - (10 - decimalPre));
	        }
	    }

	    /**
	     * doubleValue의 소수점과 소수점 이하자리가 없는 정수형 타입의 String을 반환한다.
	     * 1.0E8형식 or 10000000.0 이 아닌 100000000값을 return
	     * @param doubleValue
	     * @return
	     * @throws Exception
	     */
	    public static String null2CharNoPoint(double doubleValue) {

	        DecimalFormat myFormatter = new DecimalFormat("0");
	        if (doubleValue == 1.7976931348623157E+308D) {
	            return "";
	        } else {
	            return myFormatter.format(doubleValue);
	        }
	    }

	    /**
	     * Essbase의 Null값을 체크하여 0으로 되돌려준다. Null이 아닌경우 그대로 되돌려준다.
	     *
	     * @param doubleValue
	     * @return
	     * @throws Exception
	     */
	    public static double null2zero(double doubleValue) throws Exception {
	        if (doubleValue == 1.7976931348623157E+308D) {
	            return 0.0;

	        } else {
	            return doubleValue;
	        }
	    }

	    public static String outFormat(double d, int i) {
	        DecimalFormat myFormatter = new DecimalFormat();

	        if (d == 1.7976931348623157E+308D) {
	            d = 0.0D;
	        }
	        return myFormatter.format(digitRoundUp(d, myFormatter.toPattern()));
	    }

	    public static double digitRoundUp(double d, String s) {
	        if (getPointDigit(d) > getPointDigit(s)) {
	            return roundUp(d, getPointDigit(s));
	        } else {
	            return d;
	        }
	    }

	    public static int getPointDigit(String s) {
	        int i = s.lastIndexOf(".");
	        if (i != -1) {
	            return s.length() - (i + 1);
	        } else {
	            return 0;
	        }
	    }

	    public static int getPointDigit(double d) {
	        if (d % 1.0D == 0.0D) {
	            return 0;
	        } else {
	            return getPointDigit(Double.toString(d));
	        }
	    }

	    public static double roundUp(double d, int i) {
	        double d1 = i;
	        double d2 = 1D;
	        if (i > 0)
	            d2 = 10D;
	        double d3 = Math.pow(d2, d1);
	        double d4 = d * d3;
	        return (double) Math.round(d4) / d3;
	    }

	    /**
	     * 주어진 수치에 자리수 만큼 "0" 을 붙인 스트링을 얻기위한 Static 메소드
	     * @param   size        스트링으로 변환 할 전체 자리 수
	     * @param   num         스트링으로 변환 할 수치(int, long만 가능)
	     * @return  String      ex) "0001", "0000210"
	     */
	    public static String padNumber(int size, long num) {
	        String s = "";
	        boolean isMinus = false;
	        // 음수이면 양수로 처리후
	        if(num<0) {
	            num *= -1;
	            isMinus = true;
	        }

	        for(int j = size - 1; j >= 0; j--) {
	            long l1 = (long)Math.pow(10D, j);
	            long l2 = num / l1;
	            s = s + l2;
	            num -= l2 * l1;
	        }

	        if(isMinus) {
	           s = "-"+s;
	        }
	        return s;
	    }

	    /**
	     * 지정된 위치에 주어진 스트링을 첨부하는 메소드
	     * @param   orignalString   원본 스트링
	     * @param   position        주어진 스트링의 삽입 위치
	     * @param   addString       삽입될 주어진 스트링
	     * @return              "100000000"
	     *                      addString ("100000000", 3, ".") {}
	     *          return      "100000.000"
	     */
	    public static String addString(String originalString, int position, String addString) {

	        String tempString = "";
	        int tempPosition = 0;

	        if("".equals(originalString.trim())) {
	            return originalString;
	        } else if (originalString.replaceAll("-", "").length() <= position) {
	            return addString(padNumber( position+1, Long.parseLong(originalString)), position, addString);
	            //return originalString;

	        } else {
	            tempPosition = originalString.length() - position;
	            tempString = originalString.substring(0, tempPosition);
	            originalString = originalString.substring(tempPosition);

	            tempString += addString;
	            tempString += originalString;

	            return tempString;
	        }
	    }

	    /**
	     * convert a HTML special character string.
	     * <pre><code>
	     * &lt; --&gt; &amp;lt;
	     * &gt; --&gt; &amp;gt;
	     * &quot; --&gt; &amp;gt;
	     * &amp; --&gt; &amp;amp;
	     * \r or \n --&gt; &gt;br&lt\n
	     * \t --&gt; &amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;
	     * ' ' --&gt; &nbsp;</code></pre>
	     *
	     * @param value HTML special character string.
	     * @param converted HTML special character string.
	     */
	     public static String convertHtml(String value) {
	         if (value == null)
	             return "";

	         char[] arr = value.toCharArray();
	         StringBuffer sb = new StringBuffer();

	         for (int i=0; i<arr.length; i++) {

	             switch (arr[i]) {

	                 case '\n':
	                    sb.append("<br>");
	                    break;

	                 case '<':
	                     sb.append("&lt;");
	                     break;

	                 case '>':
	                     sb.append("&gt;");
	                     break;

	                 case '\r':
	                     break;

	                 //case '\t':
	                 //    sb.append("&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;");
	                 //    break;

	                 //case '\"':
	                 //    sb.append("&quot;");
	                 //    break;



	                 //case ' ':
	                 //    sb.append("&nbsp;");
	                 //    break;

	                 case '&':
	                     sb.append("&amp;");
	                     break;

	                 default :
	                     sb.append(arr[i]);
	             }
	         }

	         return sb.toString();
	     }
	     /************************************************************
	      * 전달된 문자열의 길이를 넘겨온 길이에 맞게 잘라서 넘겨준다.
	      * 잘린 String에 Attach String을 덧붙여서 리턴한다.
	      * @param src 변환할 문자열
	      ************************************************************/
	      static public String strCut(String src, int str_length, String att_str)
	      {
	          int ret_str_length = 0;
	          String ret_str = new String("");

	          // 현재 환경의 Character length를 구한다.
	          String tempMulLanChar = new String("가");
	          int lanCharLength = tempMulLanChar.length();

	          // Character가 중간에 잘리지 않게 하기위해 넣은 변수
	          int multiLanCharIndex = 0;

	          for (int i=0; i<src.length(); i++)
	          {
	              ret_str += src.charAt(i);
	              if (src.charAt(i)>'~')
	              {
	                  ret_str_length = ret_str_length + 2/lanCharLength;
	                  multiLanCharIndex++;
	              }
	              else
	              {
	                  ret_str_length = ret_str_length + 1;
	              }
	              if(ret_str_length >= str_length && (multiLanCharIndex%lanCharLength) == 0  )
	              {
	                  ret_str += defaultString(att_str);
	                  break;
	              }
	          }
	          return ret_str;
	      }

}
